@locusai/sdk 0.4.16 → 0.5.1

package/dist/index-node.js

@@ -439,13 +439,18 @@ __export(exports_worker, {
   AgentWorker: () => AgentWorker
 });
 module.exports = __toCommonJS(exports_worker);
-
-// src/ai/anthropic-client.ts
-var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var import_shared3 = require("@locusai/shared");
 
 // src/core/config.ts
 var import_node_path = require("node:path");
-var DEFAULT_MODEL = "sonnet";
+var PROVIDER = {
+  CLAUDE: "claude",
+  CODEX: "codex"
+};
+var DEFAULT_MODEL = {
+  [PROVIDER.CLAUDE]: "sonnet",
+  [PROVIDER.CODEX]: "gpt-5.1-codex-mini"
+};
 var LOCUS_CONFIG = {
   dir: ".locus",
   configFile: "config.json",
@@ -460,122 +465,9 @@ function getLocusPath(projectPath, fileName) {
   return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
 }
 
-// src/ai/anthropic-client.ts
-class AnthropicClient {
-  client;
-  model;
-  constructor(config) {
-    this.client = new import_sdk.default({
-      apiKey: config.apiKey
-    });
-    this.model = config.model || DEFAULT_MODEL;
-  }
-  async run(options) {
-    const { systemPrompt, cacheableContext = [], userPrompt } = options;
-    const systemContent = [];
-    if (systemPrompt) {
-      systemContent.push({
-        type: "text",
-        text: systemPrompt
-      });
-    }
-    for (let i = 0;i < cacheableContext.length; i++) {
-      const isLast = i === cacheableContext.length - 1;
-      systemContent.push({
-        type: "text",
-        text: cacheableContext[i],
-        ...isLast && {
-          cache_control: { type: "ephemeral" }
-        }
-      });
-    }
-    const response = await this.client.messages.create({
-      model: this.model,
-      max_tokens: 8000,
-      system: systemContent,
-      messages: [
-        {
-          role: "user",
-          content: userPrompt
-        }
-      ]
-    });
-    const textBlocks = response.content.filter((block) => block.type === "text");
-    return textBlocks.map((block) => block.text).join(`
-`);
-  }
-  async runSimple(prompt) {
-    return this.run({
-      userPrompt: prompt
-    });
-  }
-}
-
 // src/ai/claude-runner.ts
 var import_node_child_process = require("node:child_process");
-class ClaudeRunner {
-  projectPath;
-  model;
-  constructor(projectPath, model = DEFAULT_MODEL) {
-    this.projectPath = projectPath;
-    this.model = model;
-  }
-  async run(prompt, _isPlanning = false) {
-    const maxRetries = 3;
-    let lastError = null;
-    for (let attempt = 1;attempt <= maxRetries; attempt++) {
-      try {
-        return await this.executeRun(prompt);
-      } catch (error) {
-        const err = error;
-        lastError = err;
-        const isLastAttempt = attempt === maxRetries;
-        if (!isLastAttempt) {
-          const delay = Math.pow(2, attempt) * 1000;
-          console.warn(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`);
-          await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-      }
-    }
-    throw lastError || new Error("Claude CLI failed after multiple attempts");
-  }
-  executeRun(prompt) {
-    return new Promise((resolve, reject) => {
-      const args = [
-        "--dangerously-skip-permissions",
-        "--print",
-        "--model",
-        this.model
-      ];
-      const claude = import_node_child_process.spawn("claude", args, {
-        cwd: this.projectPath,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: process.env,
-        shell: true
-      });
-      let output = "";
-      let errorOutput = "";
-      claude.stdout.on("data", (data) => {
-        output += data.toString();
-      });
-      claude.stderr.on("data", (data) => {
-        errorOutput += data.toString();
-      });
-      claude.on("error", (err) => reject(new Error(`Failed to start Claude CLI (shell: true): ${err.message}. Please ensure the 'claude' command is available in your PATH.`)));
-      claude.on("close", (code) => {
-        if (code === 0)
-          resolve(output);
-        else {
-          const detail = errorOutput.trim();
-          const message = detail ? `Claude CLI error (exit code ${code}): ${detail}` : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in (run 'claude' manually to check).`;
-          reject(new Error(message));
-        }
-      });
-      claude.stdin.write(prompt);
-      claude.stdin.end();
-    });
-  }
-}
+var import_node_path2 = require("node:path");
 
 // src/utils/colors.ts
 var ESC = "\x1B[";
@@ -625,9 +517,270 @@ var c = {
   underline: (t) => c.text(t, "underline")
 };
 
-// src/agent/artifact-syncer.ts
+// src/ai/claude-runner.ts
+class ClaudeRunner {
+  model;
+  log;
+  projectPath;
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log) {
+    this.model = model;
+    this.log = log;
+    this.projectPath = import_node_path2.resolve(projectPath);
+  }
+  async run(prompt, _isPlanning = false) {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        return await this.executeRun(prompt);
+      } catch (error) {
+        const err = error;
+        lastError = err;
+        const isLastAttempt = attempt === maxRetries;
+        if (!isLastAttempt) {
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`Claude CLI attempt ${attempt} failed: ${err.message}. Retrying in ${delay}ms...`);
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
+        }
+      }
+    }
+    throw lastError || new Error("Claude CLI failed after multiple attempts");
+  }
+  executeRun(prompt) {
+    return new Promise((resolve2, reject) => {
+      const args = [
+        "--dangerously-skip-permissions",
+        "--print",
+        "--verbose",
+        "--output-format",
+        "stream-json",
+        "--include-partial-messages",
+        "--model",
+        this.model
+      ];
+      const env = {
+        ...process.env,
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color"
+      };
+      const claude = import_node_child_process.spawn("claude", args, {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        env
+      });
+      let finalResult = "";
+      let errorOutput = "";
+      let buffer = "";
+      claude.stdout.on("data", (data) => {
+        buffer += data.toString();
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const result = this.handleStreamLine(line);
+          if (result)
+            finalResult = result;
+        }
+      });
+      claude.stderr.on("data", (data) => {
+        const msg = data.toString();
+        errorOutput += msg;
+        process.stderr.write(msg);
+      });
+      claude.on("error", (err) => {
+        reject(new Error(`Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`));
+      });
+      claude.on("close", (code) => {
+        process.stdout.write(`
+`);
+        if (code === 0) {
+          resolve2(finalResult);
+        } else {
+          reject(this.createExecutionError(code, errorOutput));
+        }
+      });
+      claude.stdin.write(prompt);
+      claude.stdin.end();
+    });
+  }
+  handleStreamLine(line) {
+    if (!line.trim())
+      return null;
+    try {
+      const item = JSON.parse(line);
+      return this.processStreamItem(item);
+    } catch {
+      return null;
+    }
+  }
+  processStreamItem(item) {
+    if (item.type === "result") {
+      return item.result || "";
+    }
+    if (item.type === "stream_event" && item.event) {
+      this.handleEvent(item.event);
+    }
+    return null;
+  }
+  handleEvent(event) {
+    const { type, delta, content_block } = event;
+    if (type === "content_block_delta" && delta) {
+      if (delta.type === "text_delta" && delta.text) {
+        this.log?.(delta.text, "info");
+      }
+    } else if (type === "content_block_start" && content_block) {
+      if (content_block.type === "tool_use" && content_block.name) {
+        this.log?.(`
+
+${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
+`, "info");
+      }
+    }
+  }
+  createExecutionError(code, detail) {
+    const errorMsg = detail.trim();
+    const message = errorMsg ? `Claude CLI error (exit code ${code}): ${errorMsg}` : `Claude CLI exited with code ${code}. Please ensure the Claude CLI is installed and you are logged in.`;
+    return new Error(message);
+  }
+}
+
+// src/ai/codex-runner.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
-var import_node_path2 = require("node:path");
+var import_node_os = require("node:os");
+var import_node_path3 = require("node:path");
+class CodexRunner {
+  projectPath;
+  model;
+  log;
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log) {
+    this.projectPath = projectPath;
+    this.model = model;
+    this.log = log;
+  }
+  async run(prompt) {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        return await this.executeRun(prompt);
+      } catch (error) {
+        lastError = error;
+        if (attempt < maxRetries) {
+          const delay = Math.pow(2, attempt) * 1000;
+          console.warn(`Codex CLI attempt ${attempt} failed: ${lastError.message}. Retrying in ${delay}ms...`);
+          await this.sleep(delay);
+        }
+      }
+    }
+    throw lastError || new Error("Codex CLI failed after multiple attempts");
+  }
+  executeRun(prompt) {
+    return new Promise((resolve2, reject) => {
+      const outputPath = import_node_path3.join(import_node_os.tmpdir(), `locus-codex-${import_node_crypto.randomUUID()}.txt`);
+      const args = this.buildArgs(outputPath);
+      const codex = import_node_child_process2.spawn("codex", args, {
+        cwd: this.projectPath,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: process.env,
+        shell: false
+      });
+      let output = "";
+      let errorOutput = "";
+      const handleOutput = (data) => {
+        const msg = data.toString();
+        output += msg;
+        this.streamToConsole(msg);
+      };
+      codex.stdout.on("data", handleOutput);
+      codex.stderr.on("data", (data) => {
+        const msg = data.toString();
+        errorOutput += msg;
+        this.streamToConsole(msg);
+      });
+      codex.on("error", (err) => {
+        reject(new Error(`Failed to start Codex CLI: ${err.message}. ` + `Ensure 'codex' is installed and available in PATH.`));
+      });
+      codex.on("close", (code) => {
+        this.cleanupTempFile(outputPath);
+        if (code === 0) {
+          resolve2(this.readOutput(outputPath, output));
+        } else {
+          reject(this.createErrorFromOutput(code, errorOutput));
+        }
+      });
+      codex.stdin.write(prompt);
+      codex.stdin.end();
+    });
+  }
+  buildArgs(outputPath) {
+    const args = ["exec", "--full-auto", "--output-last-message", outputPath];
+    if (this.model) {
+      args.push("--model", this.model);
+    }
+    args.push("-");
+    return args;
+  }
+  streamToConsole(chunk) {
+    for (const rawLine of chunk.split(`
+`)) {
+      const line = rawLine.trim();
+      if (line && this.shouldDisplay(line)) {
+        const formattedLine = "[Codex]: ".concat(line.replace(/\*/g, ""));
+        this.log?.(formattedLine, "info");
+      }
+    }
+  }
+  shouldDisplay(line) {
+    return [
+      /^thinking\b/,
+      /^\*\*/,
+      /^Plan update\b/,
+      /^[→•✓]/
+    ].some((pattern) => pattern.test(line));
+  }
+  readOutput(outputPath, fallback) {
+    if (import_node_fs.existsSync(outputPath)) {
+      try {
+        const text = import_node_fs.readFileSync(outputPath, "utf-8").trim();
+        if (text)
+          return text;
+      } catch {}
+    }
+    return fallback.trim();
+  }
+  createErrorFromOutput(code, errorOutput) {
+    const detail = errorOutput.trim();
+    const message = detail ? `Codex CLI error (exit code ${code}): ${detail}` : `Codex CLI exited with code ${code}. ` + `Ensure Codex CLI is installed and you are logged in.`;
+    return new Error(message);
+  }
+  cleanupTempFile(path) {
+    try {
+      if (import_node_fs.existsSync(path))
+        import_node_fs.unlinkSync(path);
+    } catch {}
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+}
+
+// src/ai/factory.ts
+function createAiRunner(provider, config) {
+  const resolvedProvider = provider ?? PROVIDER.CLAUDE;
+  const model = config.model ?? DEFAULT_MODEL[resolvedProvider];
+  switch (resolvedProvider) {
+    case PROVIDER.CODEX:
+      return new CodexRunner(config.projectPath, model, config.log);
+    default:
+      return new ClaudeRunner(config.projectPath, model, config.log);
+  }
+}
+
+// src/agent/artifact-syncer.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
 class ArtifactSyncer {
   deps;
   constructor(deps) {
@@ -653,21 +806,21 @@ class ArtifactSyncer {
   }
   async sync() {
     const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
-    if (!import_node_fs.existsSync(artifactsDir)) {
-      import_node_fs.mkdirSync(artifactsDir, { recursive: true });
+    if (!import_node_fs2.existsSync(artifactsDir)) {
+      import_node_fs2.mkdirSync(artifactsDir, { recursive: true });
       return;
     }
     try {
-      const files = import_node_fs.readdirSync(artifactsDir);
+      const files = import_node_fs2.readdirSync(artifactsDir);
       if (files.length === 0)
         return;
       this.deps.log(`Syncing ${files.length} artifacts to server...`, "info");
       const artifactsGroupId = await this.getOrCreateArtifactsGroup();
       const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
       for (const file of files) {
-        const filePath = import_node_path2.join(artifactsDir, file);
-        if (import_node_fs.statSync(filePath).isFile()) {
-          const content = import_node_fs.readFileSync(filePath, "utf-8");
+        const filePath = import_node_path4.join(artifactsDir, file);
+        if (import_node_fs2.statSync(filePath).isFile()) {
+          const content = import_node_fs2.readFileSync(filePath, "utf-8");
           const title = file.replace(/\.md$/, "").trim();
           if (!title)
             continue;
@@ -694,28 +847,77 @@ class ArtifactSyncer {
 }
 
 // src/core/indexer.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = require("node:fs");
+var import_node_path5 = require("node:path");
 var import_globby = require("globby");
 
 class CodebaseIndexer {
   projectPath;
   indexPath;
+  fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path3.join(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = import_node_path5.join(projectPath, ".locus", "codebase-index.json");
   }
-  async index(onProgress, treeSummarizer) {
+  async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
       throw new Error("A treeSummarizer is required for this indexing method.");
     }
-    if (onProgress)
-      onProgress("Generating file tree...");
-    const gitmodulesPath = import_node_path3.join(this.projectPath, ".gitmodules");
+    onProgress?.("Generating file tree...");
+    const currentFiles = await this.getFileTree();
+    const treeString = currentFiles.join(`
+`);
+    const newTreeHash = this.hashTree(treeString);
+    const existingIndex = this.loadIndex();
+    if (!force && existingIndex?.treeHash === newTreeHash) {
+      onProgress?.("No file changes detected, skipping reindex");
+      return null;
+    }
+    const currentHashes = this.computeFileHashes(currentFiles);
+    const existingHashes = existingIndex?.fileHashes;
+    const canIncremental = !force && existingIndex && existingHashes;
+    if (canIncremental) {
+      onProgress?.("Performing incremental update");
+      const { added, deleted, modified } = this.diffFiles(currentHashes, existingHashes);
+      const changedFiles = [...added, ...modified];
+      const totalChanges = changedFiles.length + deleted.length;
+      const existingFileCount = Object.keys(existingHashes).length;
+      onProgress?.(`File changes detected: ${changedFiles.length} changed, ${added.length} added, ${deleted.length} deleted`);
+      if (existingFileCount > 0) {
+        const changeRatio = totalChanges / existingFileCount;
+        if (changeRatio <= this.fullReindexRatioThreshold && changedFiles.length > 0) {
+          onProgress?.(`Reindexing ${changedFiles.length} changed files and merging with existing index`);
+          const incrementalIndex = await treeSummarizer(changedFiles.join(`
+`));
+          const updatedIndex = this.cloneIndex(existingIndex);
+          this.removeFilesFromIndex(updatedIndex, [...deleted, ...modified]);
+          return this.mergeIndex(updatedIndex, incrementalIndex, currentHashes, newTreeHash);
+        }
+        if (changedFiles.length === 0 && deleted.length > 0) {
+          onProgress?.(`Removing ${deleted.length} deleted files from index`);
+          const updatedIndex = this.cloneIndex(existingIndex);
+          this.removeFilesFromIndex(updatedIndex, deleted);
+          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
+        }
+        if (changedFiles.length === 0 && deleted.length === 0) {
+          onProgress?.("No actual file changes, updating hashes only");
+          const updatedIndex = this.cloneIndex(existingIndex);
+          return this.applyIndexMetadata(updatedIndex, currentHashes, newTreeHash);
+        }
+        onProgress?.(`Too many changes (${(changeRatio * 100).toFixed(1)}%), performing full reindex`);
+      }
+    }
+    onProgress?.("AI is analyzing codebase structure...");
+    const index = await treeSummarizer(treeString);
+    return this.applyIndexMetadata(index, currentHashes, newTreeHash);
+  }
+  async getFileTree() {
+    const gitmodulesPath = import_node_path5.join(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (import_node_fs2.existsSync(gitmodulesPath)) {
+    if (import_node_fs3.existsSync(gitmodulesPath)) {
       try {
-        const content = import_node_fs2.readFileSync(gitmodulesPath, "utf-8");
+        const content = import_node_fs3.readFileSync(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -728,7 +930,7 @@ class CodebaseIndexer {
         }
       } catch {}
     }
-    const files = await import_globby.globby(["**/*"], {
+    return import_globby.globby(["**/*"], {
       cwd: this.projectPath,
       gitignore: true,
       ignore: [
@@ -769,18 +971,11 @@ class CodebaseIndexer {
         "**/*.{png,jpg,jpeg,gif,svg,ico,mp4,webm,wav,mp3,woff,woff2,eot,ttf,otf,pdf,zip,tar.gz,rar}"
       ]
     });
-    const treeString = files.join(`
-`);
-    if (onProgress)
-      onProgress("AI is analyzing codebase structure...");
-    const index = await treeSummarizer(treeString);
-    index.lastIndexed = new Date().toISOString();
-    return index;
   }
   loadIndex() {
-    if (import_node_fs2.existsSync(this.indexPath)) {
+    if (import_node_fs3.existsSync(this.indexPath)) {
       try {
-        return JSON.parse(import_node_fs2.readFileSync(this.indexPath, "utf-8"));
+        return JSON.parse(import_node_fs3.readFileSync(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -788,11 +983,84 @@ class CodebaseIndexer {
     return null;
   }
   saveIndex(index) {
-    const dir = import_node_path3.dirname(this.indexPath);
-    if (!import_node_fs2.existsSync(dir)) {
-      import_node_fs2.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path5.dirname(this.indexPath);
+    if (!import_node_fs3.existsSync(dir)) {
+      import_node_fs3.mkdirSync(dir, { recursive: true });
+    }
+    import_node_fs3.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+  }
+  cloneIndex(index) {
+    return JSON.parse(JSON.stringify(index));
+  }
+  applyIndexMetadata(index, fileHashes, treeHash) {
+    index.lastIndexed = new Date().toISOString();
+    index.treeHash = treeHash;
+    index.fileHashes = fileHashes;
+    return index;
+  }
+  hashTree(tree) {
+    return import_node_crypto2.createHash("sha256").update(tree).digest("hex");
+  }
+  hashFile(filePath) {
+    try {
+      const content = import_node_fs3.readFileSync(import_node_path5.join(this.projectPath, filePath), "utf-8");
+      return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
+    } catch {
+      return null;
     }
-    import_node_fs2.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+  }
+  computeFileHashes(files) {
+    const hashes = {};
+    for (const file of files) {
+      const hash = this.hashFile(file);
+      if (hash !== null) {
+        hashes[file] = hash;
+      }
+    }
+    return hashes;
+  }
+  diffFiles(currentHashes, existingHashes) {
+    const currentFiles = Object.keys(currentHashes);
+    const existingFiles = Object.keys(existingHashes);
+    const existingSet = new Set(existingFiles);
+    const currentSet = new Set(currentFiles);
+    const added = currentFiles.filter((f) => !existingSet.has(f));
+    const deleted = existingFiles.filter((f) => !currentSet.has(f));
+    const modified = currentFiles.filter((f) => existingSet.has(f) && currentHashes[f] !== existingHashes[f]);
+    return { added, deleted, modified };
+  }
+  removeFilesFromIndex(index, files) {
+    const fileSet = new Set(files);
+    for (const file of files) {
+      delete index.responsibilities[file];
+    }
+    for (const [symbol, paths] of Object.entries(index.symbols)) {
+      index.symbols[symbol] = paths.filter((p) => !fileSet.has(p));
+      if (index.symbols[symbol].length === 0) {
+        delete index.symbols[symbol];
+      }
+    }
+  }
+  mergeIndex(existing, incremental, newHashes, newTreeHash) {
+    const mergedSymbols = { ...existing.symbols };
+    for (const [symbol, paths] of Object.entries(incremental.symbols)) {
+      if (mergedSymbols[symbol]) {
+        mergedSymbols[symbol] = [
+          ...new Set([...mergedSymbols[symbol], ...paths])
+        ];
+      } else {
+        mergedSymbols[symbol] = paths;
+      }
+    }
+    const merged = {
+      symbols: mergedSymbols,
+      responsibilities: {
+        ...existing.responsibilities,
+        ...incremental.responsibilities
+      },
+      lastIndexed: ""
+    };
+    return this.applyIndexMetadata(merged, newHashes, newTreeHash);
   }
 }
 
@@ -804,9 +1072,8 @@ class CodebaseIndexerService {
     this.deps = deps;
     this.indexer = new CodebaseIndexer(deps.projectPath);
   }
-  async reindex() {
+  async reindex(force = false) {
     try {
-      this.deps.log("Reindexing codebase...", "info");
       const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
         const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
 1. Key symbols (classes, functions, types) and their locations
@@ -821,21 +1088,17 @@ File tree:
 ${tree}
 
 Return ONLY valid JSON, no markdown formatting.`;
-        let response;
-        if (this.deps.anthropicClient) {
-          response = await this.deps.anthropicClient.run({
-            systemPrompt: "You are a codebase analysis expert specialized in extracting structure and symbols from file trees.",
-            userPrompt: prompt
-          });
-        } else {
-          response = await this.deps.claudeRunner.run(prompt, true);
-        }
+        const response = await this.deps.aiRunner.run(prompt, true);
         const jsonMatch = response.match(/\{[\s\S]*\}/);
         if (jsonMatch) {
           return JSON.parse(jsonMatch[0]);
         }
         return { symbols: {}, responsibilities: {}, lastIndexed: "" };
-      });
+      }, force);
+      if (index === null) {
+        this.deps.log("No changes detected, skipping reindex", "info");
+        return;
+      }
       this.indexer.saveIndex(index);
       this.deps.log("Codebase reindexed successfully", "success");
     } catch (error) {
@@ -855,30 +1118,7 @@ class SprintPlanner {
     try {
       const taskList = tasks2.map((t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`).join(`
 `);
-      let plan;
-      if (this.deps.anthropicClient) {
-        const systemPrompt = `You are an expert project manager and lead engineer specialized in sprint planning and task prioritization.`;
-        const userPrompt = `# Sprint Planning: ${sprint.name}
-
-## Tasks
-${taskList}
-
-## Instructions
-1. Analyze dependencies between these tasks.
-2. Prioritize them for the most efficient execution.
-3. Create a mindmap (in Markdown or Mermaid format) that visualizes the sprint structure.
-4. Output your final plan. The plan should clearly state the order of execution.
-
-**IMPORTANT**: 
-- Do NOT create any files on the filesystem during this planning phase. 
-- Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
-- Your output will be saved as the official sprint mindmap on the server.`;
-        plan = await this.deps.anthropicClient.run({
-          systemPrompt,
-          userPrompt
-        });
-      } else {
-        const planningPrompt = `# Sprint Planning: ${sprint.name}
+      const planningPrompt = `# Sprint Planning: ${sprint.name}
 
 You are an expert project manager and lead engineer. You need to create a mindmap and execution plan for the following tasks in this sprint.
 
@@ -895,8 +1135,7 @@ ${taskList}
 - Do NOT create any files on the filesystem during this planning phase. 
 - Avoid using absolute local paths (e.g., /Users/...) in your output. Use relative paths starting from the project root if necessary.
 - Your output will be saved as the official sprint mindmap on the server.`;
-        plan = await this.deps.claudeRunner.run(planningPrompt, true);
-      }
+      const plan = await this.deps.aiRunner.run(planningPrompt, true);
       this.deps.log("Sprint mindmap generated and posted to server.", "success");
       return plan;
     } catch (error) {
@@ -907,7 +1146,7 @@ ${taskList}
 }
 
 // src/core/prompt-builder.ts
-var import_node_fs3 = require("node:fs");
+var import_node_fs4 = require("node:fs");
 var import_shared2 = require("@locusai/shared");
 class PromptBuilder {
   projectPath;
@@ -930,9 +1169,9 @@ ${task.description || "No description provided."}
 
 `;
     const contextPath = getLocusPath(this.projectPath, "contextFile");
-    if (import_node_fs3.existsSync(contextPath)) {
+    if (import_node_fs4.existsSync(contextPath)) {
       try {
-        const context = import_node_fs3.readFileSync(contextPath, "utf-8");
+        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
         prompt += `## Project Context (from CLAUDE.md)
 ${context}
 
@@ -942,7 +1181,7 @@ ${context}
       }
     }
     const indexPath = getLocusPath(this.projectPath, "indexFile");
-    if (import_node_fs3.existsSync(indexPath)) {
+    if (import_node_fs4.existsSync(indexPath)) {
       prompt += `## Codebase Overview
 There is an index file in the .locus/codebase-index.json and if you need you can check it.
 
@@ -1033,22 +1272,20 @@ ${this.deps.sprintPlan}
 ${basePrompt}`;
     }
     try {
-      let plan = "";
-      if (this.deps.anthropicClient) {
-        this.deps.log("Phase 1: Planning (Anthropic SDK)...", "info");
-        const cacheableContext = [basePrompt];
-        plan = await this.deps.anthropicClient.run({
-          systemPrompt: "You are an expert software engineer. Analyze the task carefully and create a detailed implementation plan.",
-          cacheableContext,
-          userPrompt: `## Phase 1: Planning
-Analyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.`
-        });
+      let plan = null;
+      if (this.deps.skipPlanning) {
+        this.deps.log("Skipping Phase 1: Planning (CLI)...", "info");
       } else {
-        this.deps.log("Skipping Phase 1: Planning (No Anthropic API Key)...", "info");
+        this.deps.log("Phase 1: Planning (CLI)...", "info");
+        const planningPrompt = `${basePrompt}
+
+## Phase 1: Planning
+Analyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.`;
+        plan = await this.deps.aiRunner.run(planningPrompt, true);
       }
       this.deps.log("Starting Execution...", "info");
       let executionPrompt = basePrompt;
-      if (plan) {
+      if (plan != null) {
         executionPrompt += `
 
 ## Phase 2: Execution
@@ -1064,11 +1301,11 @@ Execute the task directly.`;
       executionPrompt += `
 
 When finished, output: <promise>COMPLETE</promise>`;
-      const output = await this.deps.claudeRunner.run(executionPrompt);
+      const output = await this.deps.aiRunner.run(executionPrompt);
       const success = output.includes("<promise>COMPLETE</promise>");
       return {
         success,
-        summary: success ? "Task completed by Claude" : "Claude did not signal completion"
+        summary: success ? "Task completed by the agent" : "The agent did not signal completion"
       };
     } catch (error) {
       return { success: false, summary: `Error: ${error}` };
@@ -1077,17 +1314,27 @@ When finished, output: <promise>COMPLETE</promise>`;
 }
 
 // src/agent/worker.ts
+function resolveProvider(value) {
+  if (!value || value.startsWith("--")) {
+    console.warn("Warning: --provider requires a value. Falling back to 'claude'.");
+    return PROVIDER.CLAUDE;
+  }
+  if (value === PROVIDER.CLAUDE || value === PROVIDER.CODEX)
+    return value;
+  console.warn(`Warning: invalid --provider value '${value}'. Falling back to 'claude'.`);
+  return PROVIDER.CLAUDE;
+}
+
 class AgentWorker {
   config;
   client;
-  claudeRunner;
-  anthropicClient;
+  aiRunner;
   sprintPlanner;
   indexerService;
   artifactSyncer;
   taskExecutor;
   consecutiveEmpty = 0;
-  maxEmpty = 10;
+  maxEmpty = 5;
   maxTasks = 50;
   tasksCompleted = 0;
   pollInterval = 1e4;
@@ -1105,41 +1352,37 @@ class AgentWorker {
         factor: 2
       }
     });
-    this.claudeRunner = new ClaudeRunner(projectPath, config.model);
-    this.anthropicClient = config.anthropicApiKey ? new AnthropicClient({
-      apiKey: config.anthropicApiKey,
-      model: config.model
-    }) : null;
-    const logFn = this.log.bind(this);
+    const log = this.log.bind(this);
+    const provider = config.provider ?? PROVIDER.CLAUDE;
+    this.aiRunner = createAiRunner(provider, {
+      projectPath,
+      model: config.model,
+      log
+    });
     this.sprintPlanner = new SprintPlanner({
-      anthropicClient: this.anthropicClient,
-      claudeRunner: this.claudeRunner,
-      log: logFn
+      aiRunner: this.aiRunner,
+      log
     });
     this.indexerService = new CodebaseIndexerService({
-      anthropicClient: this.anthropicClient,
-      claudeRunner: this.claudeRunner,
+      aiRunner: this.aiRunner,
       projectPath,
-      log: logFn
+      log
     });
     this.artifactSyncer = new ArtifactSyncer({
       client: this.client,
       workspaceId: config.workspaceId,
       projectPath,
-      log: logFn
+      log
     });
     this.taskExecutor = new TaskExecutor({
-      anthropicClient: this.anthropicClient,
-      claudeRunner: this.claudeRunner,
+      aiRunner: this.aiRunner,
       projectPath,
       sprintPlan: null,
-      log: logFn
+      skipPlanning: config.skipPlanning,
+      log
     });
-    if (this.anthropicClient) {
-      this.log("Using Anthropic SDK with prompt caching for planning phases", "info");
-    } else {
-      this.log("Using Claude CLI for all phases", "info");
-    }
+    const providerLabel = provider === "codex" ? "Codex" : "Claude";
+    this.log(`Using ${providerLabel} CLI for all phases`, "info");
   }
   log(message, level = "info") {
     const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
@@ -1186,16 +1429,17 @@ class AgentWorker {
       const tasks2 = await this.client.tasks.list(this.config.workspaceId, {
         sprintId: sprint.id
       });
-      this.log(`Sprint tasks found: ${tasks2.length}`, "info");
-      const latestTaskCreation = tasks2.reduce((latest, task) => {
-        const taskDate = new Date(task.createdAt);
-        return taskDate > latest ? taskDate : latest;
-      }, new Date(0));
-      const mindmapDate = sprint.mindmapUpdatedAt ? new Date(sprint.mindmapUpdatedAt) : new Date(0);
-      if (tasks2.length <= 1) {
+      const activeTasks = tasks2.filter((t) => t.status === import_shared3.TaskStatus.BACKLOG || t.status === import_shared3.TaskStatus.IN_PROGRESS);
+      this.log(`Sprint tasks found: ${activeTasks.length}`, "info");
+      if (activeTasks.length <= 1) {
         this.log("Skipping mindmap generation (only one task in sprint).", "info");
         this.sprintPlan = null;
       } else {
+        const latestTaskCreation = activeTasks.reduce((latest, task) => {
+          const taskDate = new Date(task.createdAt);
+          return taskDate > latest ? taskDate : latest;
+        }, new Date(0));
+        const mindmapDate = sprint.mindmapUpdatedAt ? new Date(sprint.mindmapUpdatedAt) : new Date(0);
         const needsPlanning = !sprint.mindmap || sprint.mindmap.trim() === "" || latestTaskCreation > mindmapDate;
         if (needsPlanning) {
           if (sprint.mindmap && latestTaskCreation > mindmapDate) {
@@ -1217,6 +1461,9 @@ class AgentWorker {
     while (this.tasksCompleted < this.maxTasks && this.consecutiveEmpty < this.maxEmpty) {
       const task = await this.getNextTask();
       if (!task) {
+        if (this.consecutiveEmpty === 0) {
+          this.log("Queue empty, waiting for tasks...", "info");
+        }
         this.consecutiveEmpty++;
         if (this.consecutiveEmpty >= this.maxEmpty)
           break;
@@ -1228,6 +1475,7 @@ class AgentWorker {
       const result = await this.executeTask(task);
       await this.artifactSyncer.sync();
       if (result.success) {
+        this.log(`Completed: ${task.title}`, "success");
         await this.client.tasks.update(task.id, this.config.workspaceId, {
           status: "VERIFICATION"
         });
@@ -1237,6 +1485,7 @@ class AgentWorker {
         });
         this.tasksCompleted++;
       } else {
+        this.log(`Failed: ${task.title} - ${result.summary}`, "error");
         await this.client.tasks.update(task.id, this.config.workspaceId, {
           status: "BACKLOG",
           assignedTo: null
@@ -1265,12 +1514,17 @@ if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("work
       config.apiBase = args[++i];
     else if (arg === "--api-key")
       config.apiKey = args[++i];
-    else if (arg === "--anthropic-api-key")
-      config.anthropicApiKey = args[++i];
     else if (arg === "--project-path")
       config.projectPath = args[++i];
     else if (arg === "--model")
       config.model = args[++i];
+    else if (arg === "--provider") {
+      const value = args[i + 1];
+      if (value && !value.startsWith("--"))
+        i++;
+      config.provider = resolveProvider(value);
+    } else if (arg === "--skip-planning")
+      config.skipPlanning = true;
   }
   if (!config.agentId || !config.workspaceId || !config.apiBase || !config.apiKey || !config.projectPath) {
     console.error("Missing required arguments");
@@ -1287,6 +1541,7 @@ if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("work
 var exports_index_node = {};
 __export(exports_index_node, {
   getLocusPath: () => getLocusPath,
+  createAiRunner: () => createAiRunner,
   c: () => c,
   WorkspacesModule: () => WorkspacesModule,
   TasksModule: () => TasksModule,
@@ -1294,6 +1549,7 @@ __export(exports_index_node, {
   SprintsModule: () => SprintsModule,
   SprintPlanner: () => SprintPlanner,
   PromptBuilder: () => PromptBuilder,
+  PROVIDER: () => PROVIDER,
   OrganizationsModule: () => OrganizationsModule,
   LocusEvent: () => LocusEvent,
   LocusEmitter: () => LocusEmitter,
@@ -1302,23 +1558,23 @@ __export(exports_index_node, {
   InvitationsModule: () => InvitationsModule,
   DocsModule: () => DocsModule,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
+  CodexRunner: () => CodexRunner,
   CodebaseIndexerService: () => CodebaseIndexerService,
   CodebaseIndexer: () => CodebaseIndexer,
   ClaudeRunner: () => ClaudeRunner,
   CiModule: () => CiModule,
   AuthModule: () => AuthModule,
   ArtifactSyncer: () => ArtifactSyncer,
-  AnthropicClient: () => AnthropicClient,
   AgentWorker: () => AgentWorker,
   AgentOrchestrator: () => AgentOrchestrator
 });
 module.exports = __toCommonJS(exports_index_node);
 // src/orchestrator.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
-var import_node_path4 = require("node:path");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs5 = require("node:fs");
+var import_node_path6 = require("node:path");
 var import_node_url = require("node:url");
-var import_shared3 = require("@locusai/shared");
+var import_shared4 = require("@locusai/shared");
 var import_events3 = require("events");
 class AgentOrchestrator extends import_events3.EventEmitter {
   client;
@@ -1412,9 +1668,9 @@ ${c.success("✅ Orchestrator finished")}`);
 `);
     const potentialPaths = [];
     const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator.ts");
-    const currentModuleDir = import_node_path4.dirname(currentModulePath);
-    potentialPaths.push(import_node_path4.join(currentModuleDir, "agent", "worker.js"), import_node_path4.join(currentModuleDir, "worker.js"), import_node_path4.join(currentModuleDir, "agent", "worker.ts"));
-    const workerPath = potentialPaths.find((p) => import_node_fs4.existsSync(p));
+    const currentModuleDir = import_node_path6.dirname(currentModulePath);
+    potentialPaths.push(import_node_path6.join(currentModuleDir, "agent", "worker.js"), import_node_path6.join(currentModuleDir, "worker.js"), import_node_path6.join(currentModuleDir, "agent", "worker.ts"));
+    const workerPath = potentialPaths.find((p) => import_node_fs5.existsSync(p));
     if (!workerPath) {
       throw new Error(`Worker file not found. Checked: ${potentialPaths.join(", ")}. ` + `Make sure the SDK is properly built and installed.`);
     }
@@ -1430,16 +1686,26 @@ ${c.success("✅ Orchestrator finished")}`);
       "--project-path",
       this.config.projectPath
     ];
-    if (this.config.anthropicApiKey) {
-      workerArgs.push("--anthropic-api-key", this.config.anthropicApiKey);
-    }
     if (this.config.model) {
       workerArgs.push("--model", this.config.model);
     }
+    if (this.config.provider) {
+      workerArgs.push("--provider", this.config.provider);
+    }
+    if (this.config.skipPlanning) {
+      workerArgs.push("--skip-planning");
+    }
     if (this.resolvedSprintId) {
       workerArgs.push("--sprint-id", this.resolvedSprintId);
     }
-    const agentProcess = import_node_child_process2.spawn(process.execPath, [workerPath, ...workerArgs]);
+    const agentProcess = import_node_child_process3.spawn(process.execPath, [workerPath, ...workerArgs], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color"
+      }
+    });
     agentState.process = agentProcess;
     agentProcess.on("message", (msg) => {
       if (msg.type === "stats") {
@@ -1451,7 +1717,7 @@ ${c.success("✅ Orchestrator finished")}`);
       process.stdout.write(data.toString());
     });
     agentProcess.stderr?.on("data", (data) => {
-      process.stderr.write(`[${agentId}] ERR: ${data.toString()}`);
+      process.stderr.write(data.toString());
     });
     agentProcess.on("exit", (code) => {
       console.log(`
@@ -1487,10 +1753,10 @@ ${agentId} finished (exit code: ${code})`);
     try {
       const tasks2 = await this.getAvailableTasks();
       const priorityOrder = [
-        import_shared3.TaskPriority.CRITICAL,
-        import_shared3.TaskPriority.HIGH,
-        import_shared3.TaskPriority.MEDIUM,
-        import_shared3.TaskPriority.LOW
+        import_shared4.TaskPriority.CRITICAL,
+        import_shared4.TaskPriority.HIGH,
+        import_shared4.TaskPriority.MEDIUM,
+        import_shared4.TaskPriority.LOW
       ];
       let task = tasks2.sort((a, b) => priorityOrder.indexOf(a.priority) - priorityOrder.indexOf(b.priority))[0];
       if (!task && tasks2.length > 0) {
@@ -1514,7 +1780,7 @@ ${agentId} finished (exit code: ${code})`);
   async completeTask(taskId, agentId, summary) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared3.TaskStatus.VERIFICATION
+        status: import_shared4.TaskStatus.VERIFICATION
       });
       if (summary) {
         await this.client.tasks.addComment(taskId, this.config.workspaceId, {
@@ -1539,7 +1805,7 @@ ${summary}`
   async failTask(taskId, agentId, error) {
     try {
       await this.client.tasks.update(taskId, this.config.workspaceId, {
-        status: import_shared3.TaskStatus.BACKLOG,
+        status: import_shared4.TaskStatus.BACKLOG,
         assignedTo: null
       });
       await this.client.tasks.addComment(taskId, this.config.workspaceId, {
@@ -1580,6 +1846,6 @@ ${summary}`
     };
   }
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
 }