refactor: improve argument handling and dependency resolution in apply and push processes

- Updated `apply.ts` to ensure the `--force` option does not affect pull commands, preserving local changes.
- Removed outdated logic for resolving `assistantId` in `pull.ts` and `resolver.ts`, streamlining the dependency resolution process.
- Enhanced `push.ts` to ensure proper handling of tool and structured output dependencies, improving the clarity of auto-application logs.
- Cleaned up unnecessary comments and code related to assistant overrides, simplifying the overall codebase.

Author: vtkovapi

src/apply.ts

@@ -29,7 +29,8 @@ async function main(): Promise<void> {
   const allArgs = process.argv.slice(3);
   const hasForce = allArgs.includes("--force");
 
-  const pullArgs = allArgs.join(" ");
+  // Pull never gets --force (apply's pull should always preserve local changes/deletions)
+  const pullArgs = allArgs.filter(a => a !== "--force").join(" ");
   const pushArgs = allArgs.join(" ");
 
   if (!env || !VALID_ENVIRONMENTS.includes(env as typeof VALID_ENVIRONMENTS[number])) {
@@ -53,7 +54,7 @@ async function main(): Promise<void> {
   }
   console.log("═══════════════════════════════════════════════════════════════\n");
 
-  // Step 1: Pull (--force forwarded: platform becomes source of truth, deletes orphaned local files)
+  // Step 1: Pull (never forced — always preserves local deletions/changes)
   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, unlink } from "fs/promises";
+import { mkdir, writeFile } 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,21 +335,6 @@ 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;
     });
   }
@@ -568,25 +553,6 @@ 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,13 +400,12 @@ interface DependencyContext {
 }
 
 async function ensureToolExists(toolId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(toolId) || ctx.autoApplied.has(`tools:${toolId}`)) return;
+  if (UUID_REGEX.test(toolId) || ctx.state.tools[toolId] || ctx.autoApplied.has(`tools:${toolId}`)) return;
 
   const tool = ctx.allTools.find(t => t.resourceId === toolId);
   if (!tool) return;
 
-  const isUpdate = !!ctx.state.tools[toolId];
-  console.log(`  📦 Auto-applying dependency → tool: ${toolId}${isUpdate ? " (update)" : ""}`);
+  console.log(`  📦 Auto-applying dependency → tool: ${toolId}`);
   try {
     const uuid = await applyTool(tool, ctx.state);
     ctx.state.tools[tool.resourceId] = uuid;
@@ -420,13 +419,12 @@ async function ensureToolExists(toolId: string, ctx: DependencyContext): Promise
 }
 
 async function ensureStructuredOutputExists(outputId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(outputId) || ctx.autoApplied.has(`structuredOutputs:${outputId}`)) return;
+  if (UUID_REGEX.test(outputId) || ctx.state.structuredOutputs[outputId] || ctx.autoApplied.has(`structuredOutputs:${outputId}`)) return;
 
   const output = ctx.allStructuredOutputs.find(o => o.resourceId === outputId);
   if (!output) return;
 
-  const isUpdate = !!ctx.state.structuredOutputs[outputId];
-  console.log(`  📦 Auto-applying dependency → structured output: ${outputId}${isUpdate ? " (update)" : ""}`);
+  console.log(`  📦 Auto-applying dependency → structured output: ${outputId}`);
   try {
     const uuid = await applyStructuredOutput(output, ctx.state);
     ctx.state.structuredOutputs[output.resourceId] = uuid;
@@ -439,32 +437,55 @@ async function ensureStructuredOutputExists(outputId: string, ctx: DependencyCon
   }
 }
 
-async function ensureAssistantDepsExist(assistantId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(assistantId)) return;
+async function ensureAssistantDepsExist(assistantId: string, ctx: DependencyContext): Promise<boolean> {
+  if (UUID_REGEX.test(assistantId)) return false;
 
   const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
-  if (!assistant) return;
+  if (!assistant) return false;
 
   const refs = extractReferencedIds(assistant.data as Record<string, unknown>);
+  let depsCreated = false;
 
   for (const toolId of refs.tools) {
-    await ensureToolExists(toolId, ctx);
+    if (!UUID_REGEX.test(toolId) && !ctx.state.tools[toolId]) {
+      await ensureToolExists(toolId, ctx);
+      if (ctx.state.tools[toolId]) depsCreated = true;
+    }
   }
   for (const outputId of refs.structuredOutputs) {
-    await ensureStructuredOutputExists(outputId, ctx);
+    if (!UUID_REGEX.test(outputId) && !ctx.state.structuredOutputs[outputId]) {
+      await ensureStructuredOutputExists(outputId, ctx);
+      if (ctx.state.structuredOutputs[outputId]) depsCreated = true;
+    }
   }
+
+  return depsCreated;
 }
 
 async function ensureAssistantExists(assistantId: string, ctx: DependencyContext): Promise<void> {
-  if (UUID_REGEX.test(assistantId) || ctx.autoApplied.has(`assistants:${assistantId}`)) return;
+  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;
+  }
 
-  await ensureAssistantDepsExist(assistantId, ctx);
+  if (ctx.autoApplied.has(`assistants:${assistantId}`)) return;
 
   const assistant = ctx.allAssistants.find(a => a.resourceId === assistantId);
   if (!assistant) return;
 
-  const isUpdate = !!ctx.state.assistants[assistantId];
-  console.log(`  📦 Auto-applying dependency → assistant: ${assistantId}${isUpdate ? " (update)" : ""}`);
+  console.log(`  📦 Auto-applying dependency → assistant: ${assistantId}`);
   try {
     const uuid = await applyAssistant(assistant, ctx.state);
     ctx.state.assistants[assistant.resourceId] = uuid;

src/resolver.ts

@@ -262,23 +262,6 @@ 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;
-                }
-              }
-            }
-          }
-        }
-      }
     }
   }
 
@@ -418,20 +401,6 @@ 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));
-              }
-            }
-          }
-        }
-      }
     }
   }