feat: enhance apply and pull logic with improved handling of force option and assistant ID resolution

- Updated the `apply.ts` script to simplify argument handling for pull commands, ensuring local changes are preserved.
- Enhanced the pull functionality in `pull.ts` to delete local files for resources removed from the platform when the force option is used.
- Implemented resolution of `assistantId` in `assistantOverrides` for tools, ensuring correct mapping during resource processing.
- Improved logging to indicate updates and removals, providing clearer feedback during operations.

Author: vtkovapi

src/apply.ts

@@ -29,8 +29,7 @@ async function main(): Promise<void> {
   const allArgs = process.argv.slice(3);
   const hasForce = allArgs.includes("--force");
 
-  // Pull never gets --force (apply's pull should always preserve local changes/deletions)
-  const pullArgs = allArgs.filter(a => a !== "--force").join(" ");
+  const pullArgs = allArgs.join(" ");
   const pushArgs = allArgs.join(" ");
 
   if (!env || !VALID_ENVIRONMENTS.includes(env as typeof VALID_ENVIRONMENTS[number])) {
@@ -54,7 +53,7 @@ async function main(): Promise<void> {
   }
   console.log("═══════════════════════════════════════════════════════════════\n");
 
-  // Step 1: Pull (never forced — always preserves local deletions/changes)
+  // Step 1: Pull (--force forwarded: platform becomes source of truth, deletes orphaned local files)
   const pullCmd = `npx tsx src/pull.ts ${env} ${pullArgs}`.trim();
   const pullExit = runPassthrough(pullCmd);
   if (pullExit !== 0) {

src/pull.ts

@@ -1,6 +1,6 @@
 import { execSync } from "child_process";
 import { existsSync, readdirSync } from "fs";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir, writeFile, unlink } from "fs/promises";
 import { join, dirname, relative } from "path";
 import { stringify } from "yaml";
 import { VAPI_ENV, VAPI_BASE_URL, VAPI_TOKEN, RESOURCES_DIR, BASE_DIR, APPLY_FILTER } from "./config.ts";
@@ -335,6 +335,21 @@ function resolveReferencesToResourceIds(
           return dest;
         });
       }
+      // Resolve assistantId in assistantOverrides["tools:append"][].destinations[]
+      const overrides = resolvedMember.assistantOverrides as Record<string, unknown> | undefined;
+      const toolsAppend = overrides?.["tools:append"] as Record<string, unknown>[] | undefined;
+      if (Array.isArray(toolsAppend)) {
+        for (const tool of toolsAppend) {
+          if (Array.isArray(tool.destinations)) {
+            tool.destinations = (tool.destinations as Record<string, unknown>[]).map((dest) => {
+              if (typeof dest.assistantId === "string") {
+                return { ...dest, assistantId: assistantsMap.get(dest.assistantId) ?? dest.assistantId };
+              }
+              return dest;
+            });
+          }
+        }
+      }
       return resolvedMember;
     });
   }
@@ -553,6 +568,25 @@ export async function pullResourceType(
     newStateSection[resourceId] = resource.id;
   }
 
+  // In force mode, delete local files for resources removed from the platform
+  if (force) {
+    const oldStateSection = state[resourceType];
+    for (const [resourceId] of Object.entries(oldStateSection)) {
+      if (newStateSection[resourceId]) continue;
+      const folderPath = FOLDER_MAP[resourceType];
+      const dir = join(RESOURCES_DIR, folderPath);
+      for (const ext of [".md", ".yml", ".yaml"]) {
+        const filePath = join(dir, `${resourceId}${ext}`);
+        if (existsSync(filePath)) {
+          await unlink(filePath);
+          const relPath = relative(BASE_DIR, filePath);
+          console.log(`   🗑️  ${resourceId} -> ${relPath} (removed from platform)`);
+          break;
+        }
+      }
+    }
+  }
+
   // Update state with new mappings
   state[resourceType] = newStateSection;
 

src/push.ts

@@ -400,12 +400,13 @@ interface DependencyContext {
 }
 
 async function ensureToolExists(toolId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(toolId) || ctx.state.tools[toolId] || ctx.autoApplied.has(`tools:${toolId}`)) return;
+  if (UUID_REGEX.test(toolId) || ctx.autoApplied.has(`tools:${toolId}`)) return;
 
   const tool = ctx.allTools.find(t => t.resourceId === toolId);
   if (!tool) return;
 
-  console.log(`  📦 Auto-applying dependency → tool: ${toolId}`);
+  const isUpdate = !!ctx.state.tools[toolId];
+  console.log(`  📦 Auto-applying dependency → tool: ${toolId}${isUpdate ? " (update)" : ""}`);
   try {
     const uuid = await applyTool(tool, ctx.state);
     ctx.state.tools[tool.resourceId] = uuid;
@@ -419,12 +420,13 @@ async function ensureToolExists(toolId: string, ctx: DependencyContext): Promise
 }
 
 async function ensureStructuredOutputExists(outputId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(outputId) || ctx.state.structuredOutputs[outputId] || ctx.autoApplied.has(`structuredOutputs:${outputId}`)) return;
+  if (UUID_REGEX.test(outputId) || ctx.autoApplied.has(`structuredOutputs:${outputId}`)) return;
 
   const output = ctx.allStructuredOutputs.find(o => o.resourceId === outputId);
   if (!output) return;
 
-  console.log(`  📦 Auto-applying dependency → structured output: ${outputId}`);
+  const isUpdate = !!ctx.state.structuredOutputs[outputId];
+  console.log(`  📦 Auto-applying dependency → structured output: ${outputId}${isUpdate ? " (update)" : ""}`);
   try {
     const uuid = await applyStructuredOutput(output, ctx.state);
     ctx.state.structuredOutputs[output.resourceId] = uuid;
@@ -437,55 +439,32 @@ async function ensureStructuredOutputExists(outputId: string, ctx: DependencyCon
   }
 }
 
-async function ensureAssistantDepsExist(assistantId: string, ctx: DependencyContext): Promise<boolean> {
-  if (UUID_REGEX.test(assistantId)) return false;
+async function ensureAssistantDepsExist(assistantId: string, ctx: DependencyContext): Promise<void> {
+  if (UUID_REGEX.test(assistantId)) return;
 
   const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
-  if (!assistant) return false;
+  if (!assistant) return;
 
   const refs = extractReferencedIds(assistant.data as Record<string, unknown>);
-  let depsCreated = false;
 
   for (const toolId of refs.tools) {
-    if (!UUID_REGEX.test(toolId) && !ctx.state.tools[toolId]) {
-      await ensureToolExists(toolId, ctx);
-      if (ctx.state.tools[toolId]) depsCreated = true;
-    }
+    await ensureToolExists(toolId, ctx);
   }
   for (const outputId of refs.structuredOutputs) {
-    if (!UUID_REGEX.test(outputId) && !ctx.state.structuredOutputs[outputId]) {
-      await ensureStructuredOutputExists(outputId, ctx);
-      if (ctx.state.structuredOutputs[outputId]) depsCreated = true;
-    }
+    await ensureStructuredOutputExists(outputId, ctx);
   }
-
-  return depsCreated;
 }
 
 async function ensureAssistantExists(assistantId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(assistantId)) return;
-
-  // Always resolve tool/SO deps, even if the assistant already exists in state
-  const depsCreated = await ensureAssistantDepsExist(assistantId, ctx);
-
-  // Assistant already on platform — update it if we just created missing deps
-  if (ctx.state.assistants[assistantId]) {
-    if (depsCreated) {
-      const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
-      if (assistant) {
-        console.log(`  🔄 Updating assistant with new dependencies: ${assistantId}`);
-        await applyAssistant(assistant, ctx.state);
-      }
-    }
-    return;
-  }
+  if (UUID_REGEX.test(assistantId) || ctx.autoApplied.has(`assistants:${assistantId}`)) return;
 
-  if (ctx.autoApplied.has(`assistants:${assistantId}`)) return;
+  await ensureAssistantDepsExist(assistantId, ctx);
 
   const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
   if (!assistant) return;
 
-  console.log(`  📦 Auto-applying dependency → assistant: ${assistantId}`);
+  const isUpdate = !!ctx.state.assistants[assistantId];
+  console.log(`  📦 Auto-applying dependency → assistant: ${assistantId}${isUpdate ? " (update)" : ""}`);
   try {
     const uuid = await applyAssistant(assistant, ctx.state);
     ctx.state.assistants[assistant.resourceId] = uuid;

src/resolver.ts

@@ -262,6 +262,23 @@ export function resolveReferences(
           }
         }
       }
+      // Resolve assistantId in assistantOverrides["tools:append"][].destinations[]
+      const overrides = member.assistantOverrides as Record<string, unknown> | undefined;
+      const toolsAppend = overrides?.["tools:append"] as Record<string, unknown>[] | undefined;
+      if (Array.isArray(toolsAppend)) {
+        for (const tool of toolsAppend) {
+          if (Array.isArray(tool.destinations)) {
+            for (const dest of tool.destinations as Record<string, unknown>[]) {
+              if (typeof dest.assistantId === "string") {
+                const resolvedId = resolveAssistantId(dest.assistantId, state);
+                if (resolvedId) {
+                  dest.assistantId = resolvedId;
+                }
+              }
+            }
+          }
+        }
+      }
     }
   }
 
@@ -401,6 +418,20 @@ export function extractReferencedIds(data: Record<string, unknown>): ExtractedRe
           }
         }
       }
+      // Check assistantOverrides["tools:append"][].destinations[].assistantId
+      const overrides = member.assistantOverrides as Record<string, unknown> | undefined;
+      const toolsAppend = overrides?.["tools:append"] as Record<string, unknown>[] | undefined;
+      if (Array.isArray(toolsAppend)) {
+        for (const tool of toolsAppend) {
+          if (Array.isArray(tool.destinations)) {
+            for (const dest of tool.destinations as Record<string, unknown>[]) {
+              if (typeof dest.assistantId === "string") {
+                assistants.push(cleanId(dest.assistantId));
+              }
+            }
+          }
+        }
+      }
     }
   }