@locusai/sdk 0.5.1 → 0.7.0

package/dist/index-node.js

@@ -52,7 +52,8 @@ __export(exports_src, {
   InvitationsModule: () => InvitationsModule,
   DocsModule: () => DocsModule,
   CiModule: () => CiModule,
-  AuthModule: () => AuthModule
+  AuthModule: () => AuthModule,
+  AIModule: () => AIModule
 });
 module.exports = __toCommonJS(exports_src);
 var import_axios = __toESM(require("axios"));
@@ -85,12 +86,46 @@ class BaseModule {
   }
 }
 
+// src/modules/ai.ts
+class AIModule extends BaseModule {
+  async chat(workspaceId, body) {
+    const { data } = await this.api.post(`/ai/${workspaceId}/chat`, body, { timeout: 300000 });
+    return data;
+  }
+  async detectIntent(workspaceId, body) {
+    const { data } = await this.api.post(`/ai/${workspaceId}/chat/intent`, body, { timeout: 300000 });
+    return data;
+  }
+  async executeIntent(workspaceId, body) {
+    const { data } = await this.api.post(`/ai/${workspaceId}/chat/execute`, body, { timeout: 300000 });
+    return data;
+  }
+  async listSessions(workspaceId) {
+    const { data } = await this.api.get(`/ai/${workspaceId}/sessions`);
+    return data;
+  }
+  async getSession(workspaceId, sessionId) {
+    const { data } = await this.api.get(`/ai/${workspaceId}/session/${sessionId}`);
+    return data;
+  }
+  getChatStreamUrl(workspaceId, sessionId) {
+    return `${this.api.defaults.baseURL}/ai/${workspaceId}/chat/stream?sessionId=${sessionId}`;
+  }
+  async deleteSession(workspaceId, sessionId) {
+    await this.api.delete(`/ai/${workspaceId}/session/${sessionId}`);
+  }
+}
+
 // src/modules/auth.ts
 class AuthModule extends BaseModule {
-  async getMe() {
+  async getProfile() {
     const { data } = await this.api.get("/auth/me");
     return data;
   }
+  async getApiKeyInfo() {
+    const { data } = await this.api.get("/auth/api-key");
+    return data;
+  }
   async requestRegisterOtp(email) {
     const { data } = await this.api.post("/auth/register-otp", { email });
     return data;
@@ -248,6 +283,10 @@ class SprintsModule extends BaseModule {
     const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/complete`);
     return data.sprint;
   }
+  async triggerAIPlanning(id, workspaceId) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/sprints/${id}/trigger-ai-planning`);
+    return data.sprint;
+  }
 }
 
 // src/modules/tasks.ts
@@ -294,6 +333,16 @@ class TasksModule extends BaseModule {
     const { data } = await this.api.post(`/workspaces/${workspaceId}/tasks/${id}/comment`, body);
     return data.comment;
   }
+  async batchUpdate(ids, workspaceId, updates) {
+    await this.api.patch(`/workspaces/${workspaceId}/tasks/batch`, {
+      ids,
+      updates
+    });
+  }
+  async getContext(id, workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/tasks/${id}/context`);
+    return data;
+  }
 }
 
 // src/modules/workspaces.ts
@@ -340,6 +389,17 @@ class WorkspacesModule extends BaseModule {
     const { data } = await this.api.post(`/workspaces/${id}/dispatch`, { workerId, sprintId });
     return data.task;
   }
+  async listApiKeys(workspaceId) {
+    const { data } = await this.api.get(`/workspaces/${workspaceId}/api-keys`);
+    return data.apiKeys;
+  }
+  async createApiKey(workspaceId, name) {
+    const { data } = await this.api.post(`/workspaces/${workspaceId}/api-keys`, { name });
+    return data.apiKey;
+  }
+  async deleteApiKey(workspaceId, keyId) {
+    await this.api.delete(`/workspaces/${workspaceId}/api-keys/${keyId}`);
+  }
 }
 
 // src/index.ts
@@ -347,6 +407,7 @@ class LocusClient {
   api;
   emitter;
   auth;
+  ai;
   tasks;
   sprints;
   workspaces;
@@ -358,7 +419,7 @@ class LocusClient {
     this.emitter = new LocusEmitter;
     this.api = import_axios.default.create({
       baseURL: config.baseUrl,
-      timeout: config.timeout || 1e4,
+      timeout: config.timeout || 60000,
       headers: {
         "Content-Type": "application/json",
         ...config.token ? { Authorization: `Bearer ${config.token}` } : {}
@@ -366,6 +427,7 @@ class LocusClient {
     });
     this.setupInterceptors();
     this.auth = new AuthModule(this.api, this.emitter);
+    this.ai = new AIModule(this.api, this.emitter);
     this.tasks = new TasksModule(this.api, this.emitter);
     this.sprints = new SprintsModule(this.api, this.emitter);
     this.workspaces = new WorkspacesModule(this.api, this.emitter);
@@ -439,7 +501,6 @@ __export(exports_worker, {
   AgentWorker: () => AgentWorker
 });
 module.exports = __toCommonJS(exports_worker);
-var import_shared3 = require("@locusai/shared");
 
 // src/core/config.ts
 var import_node_path = require("node:path");
@@ -456,7 +517,9 @@ var LOCUS_CONFIG = {
   configFile: "config.json",
   indexFile: "codebase-index.json",
   contextFile: "CLAUDE.md",
-  artifactsDir: "artifacts"
+  artifactsDir: "artifacts",
+  documentsDir: "documents",
+  agentSkillsDir: ".agent/skills"
 };
 function getLocusPath(projectPath, fileName) {
   if (fileName === "contextFile") {
@@ -571,6 +634,7 @@ class ClaudeRunner {
       let finalResult = "";
       let errorOutput = "";
       let buffer = "";
+      let stderrBuffer = "";
       claude.stdout.on("data", (data) => {
         buffer += data.toString();
         const lines = buffer.split(`
@@ -583,14 +647,27 @@ class ClaudeRunner {
         }
       });
       claude.stderr.on("data", (data) => {
-        const msg = data.toString();
-        errorOutput += msg;
-        process.stderr.write(msg);
+        const chunk = data.toString();
+        errorOutput += chunk;
+        stderrBuffer += chunk;
+        const lines = stderrBuffer.split(`
+`);
+        stderrBuffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!this.shouldSuppressLine(line)) {
+            process.stderr.write(`${line}
+`);
+          }
+        }
       });
       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) => {
+        if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
+          process.stderr.write(`${stderrBuffer}
+`);
+        }
         process.stdout.write(`
 `);
         if (code === 0) {
@@ -623,12 +700,8 @@ class ClaudeRunner {
     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) {
+    const { type, content_block } = event;
+    if (type === "content_block_start" && content_block) {
       if (content_block.type === "tool_use" && content_block.name) {
         this.log?.(`
 
@@ -637,6 +710,10 @@ ${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
       }
     }
   }
+  shouldSuppressLine(line) {
+    const infoLogRegex = /^\[\d{2}:\d{2}:\d{2}\]\s\[.*?\]\sℹ\s*$/;
+    return infoLogRegex.test(line.trim());
+  }
   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.`;
@@ -715,7 +792,13 @@ class CodexRunner {
     });
   }
   buildArgs(outputPath) {
-    const args = ["exec", "--full-auto", "--output-last-message", outputPath];
+    const args = [
+      "exec",
+      "--full-auto",
+      "--skip-git-repo-check",
+      "--output-last-message",
+      outputPath
+    ];
     if (this.model) {
       args.push("--model", this.model);
     }
@@ -781,6 +864,7 @@ function createAiRunner(provider, config) {
 // src/agent/artifact-syncer.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path4 = require("node:path");
+var import_shared2 = require("@locusai/shared");
 class ArtifactSyncer {
   deps;
   constructor(deps) {
@@ -812,10 +896,13 @@ class ArtifactSyncer {
     }
     try {
       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 groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
+      const groupMap = new Map(groups.map((g) => [g.id, g.name]));
+      let artifactsGroupId = groups.find((g) => g.name === "Artifacts")?.id;
+      if (!artifactsGroupId) {
+        artifactsGroupId = await this.getOrCreateArtifactsGroup();
+      }
       const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
       for (const file of files) {
         const filePath = import_node_path4.join(artifactsDir, file);
@@ -834,12 +921,35 @@ class ArtifactSyncer {
             await this.deps.client.docs.create(this.deps.workspaceId, {
               title,
               content,
-              groupId: artifactsGroupId
+              groupId: artifactsGroupId,
+              type: import_shared2.DocType.GENERAL
             });
             this.deps.log(`Created artifact: ${file}`, "success");
           }
         }
       }
+      for (const doc of existingDocs) {
+        if (doc.groupId === artifactsGroupId) {
+          const fileName = `${doc.title}.md`;
+          const filePath = import_node_path4.join(artifactsDir, fileName);
+          if (!import_node_fs2.existsSync(filePath)) {
+            import_node_fs2.writeFileSync(filePath, doc.content || "");
+            this.deps.log(`Fetched artifact: ${fileName}`, "success");
+          }
+        } else {
+          const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
+          const groupName = groupMap.get(doc.groupId || "") || "General";
+          const groupDir = import_node_path4.join(documentsDir, groupName);
+          if (!import_node_fs2.existsSync(groupDir)) {
+            import_node_fs2.mkdirSync(groupDir, { recursive: true });
+          }
+          const fileName = `${doc.title}.md`;
+          const filePath = import_node_path4.join(groupDir, fileName);
+          if (!import_node_fs2.existsSync(filePath) || import_node_fs2.readFileSync(filePath, "utf-8") !== doc.content) {
+            import_node_fs2.writeFileSync(filePath, doc.content || "");
+          }
+        }
+      }
     } catch (error) {
       this.deps.log(`Failed to sync artifacts: ${error}`, "error");
     }
@@ -1107,53 +1217,17 @@ Return ONLY valid JSON, no markdown formatting.`;
   }
 }
 
-// src/agent/sprint-planner.ts
-class SprintPlanner {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  async planSprint(sprint, tasks2) {
-    this.deps.log(`Planning sprint: ${sprint.name}`, "info");
-    try {
-      const taskList = tasks2.map((t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`).join(`
-`);
-      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.
-
-## 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.`;
-      const plan = await this.deps.aiRunner.run(planningPrompt, true);
-      this.deps.log("Sprint mindmap generated and posted to server.", "success");
-      return plan;
-    } catch (error) {
-      this.deps.log(`Sprint planning failed: ${error}`, "error");
-      return sprint.mindmap || "";
-    }
-  }
-}
-
 // src/core/prompt-builder.ts
 var import_node_fs4 = require("node:fs");
-var import_shared2 = require("@locusai/shared");
+var import_node_os2 = require("node:os");
+var import_node_path6 = require("node:path");
+var import_shared3 = require("@locusai/shared");
 class PromptBuilder {
   projectPath;
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
-  async build(task) {
+  async build(task, options = {}) {
     let prompt = `# Task: ${task.title}
 
 `;
@@ -1168,18 +1242,81 @@ You are acting as a ${roleText}.
 ${task.description || "No description provided."}
 
 `;
+    const projectConfig = this.getProjectConfig();
+    if (projectConfig) {
+      prompt += `## Project Metadata
+`;
+      prompt += `- Version: ${projectConfig.version || "Unknown"}
+`;
+      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
+
+`;
+    }
+    let serverContext = null;
+    if (options.taskContext) {
+      try {
+        serverContext = JSON.parse(options.taskContext);
+      } catch {
+        serverContext = { context: options.taskContext };
+      }
+    }
     const contextPath = getLocusPath(this.projectPath, "contextFile");
+    let hasLocalContext = false;
     if (import_node_fs4.existsSync(contextPath)) {
       try {
         const context = import_node_fs4.readFileSync(contextPath, "utf-8");
-        prompt += `## Project Context (from CLAUDE.md)
+        if (context.trim().length > 20) {
+          prompt += `## Project Context (Local)
 ${context}
 
 `;
+          hasLocalContext = true;
+        }
       } catch (err) {
         console.warn(`Warning: Could not read context file: ${err}`);
       }
     }
+    if (!hasLocalContext) {
+      const fallback = this.getFallbackContext();
+      if (fallback) {
+        prompt += `## Project Context (README Fallback)
+${fallback}
+
+`;
+      }
+    }
+    if (serverContext) {
+      prompt += `## Project Context (Server)
+`;
+      if (serverContext.project) {
+        prompt += `- Project: ${serverContext.project.name || "Unknown"}
+`;
+        if (!hasLocalContext && serverContext.project.techStack?.length) {
+          prompt += `- Tech Stack: ${serverContext.project.techStack.join(", ")}
+`;
+        }
+      }
+      if (serverContext.context) {
+        prompt += `
+${serverContext.context}
+`;
+      }
+      prompt += `
+`;
+    }
+    prompt += this.getProjectStructure();
+    prompt += this.getSkillsInfo();
+    prompt += `## Project Knowledge Base
+`;
+    prompt += `You have access to the following documentation directories for context:
+`;
+    prompt += `- Artifacts: \`.locus/artifacts\`
+`;
+    prompt += `- Documents: \`.locus/documents\`
+`;
+    prompt += `If you need more information about the project strategies, plans, or architecture, please read files in these directories.
+
+`;
     const indexPath = getLocusPath(this.projectPath, "indexFile");
     if (import_node_fs4.existsSync(indexPath)) {
       prompt += `## Codebase Overview
@@ -1188,11 +1325,19 @@ There is an index file in the .locus/codebase-index.json and if you need you can
 `;
     }
     if (task.docs && task.docs.length > 0) {
-      prompt += `## Attached Documents
+      prompt += `## Attached Documents (Summarized)
+`;
+      prompt += `> Full content available on server. Rely on Task Description for specific requirements.
+
 `;
       for (const doc of task.docs) {
-        prompt += `### ${doc.title}
-${doc.content || "(No content)"}
+        const content = doc.content || "";
+        const limit = 800;
+        const preview = content.slice(0, limit);
+        const isTruncated = content.length > limit;
+        prompt += `### Doc: ${doc.title}
+${preview}${isTruncated ? `
+...(truncated)...` : ""}
 
 `;
       }
@@ -1208,7 +1353,7 @@ ${doc.content || "(No content)"}
 `;
     }
     if (task.comments && task.comments.length > 0) {
-      const comments = task.comments.slice(0, 5);
+      const comments = task.comments.slice(0, 3);
       prompt += `## Task History & Feedback
 `;
       prompt += `Review the following comments for context or rejection feedback:
@@ -1230,20 +1375,122 @@ ${comment.text}
 `;
     return prompt;
   }
+  getProjectConfig() {
+    const configPath = getLocusPath(this.projectPath, "configFile");
+    if (import_node_fs4.existsSync(configPath)) {
+      try {
+        return JSON.parse(import_node_fs4.readFileSync(configPath, "utf-8"));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  getFallbackContext() {
+    const readmePath = import_node_path6.join(this.projectPath, "README.md");
+    if (import_node_fs4.existsSync(readmePath)) {
+      try {
+        const content = import_node_fs4.readFileSync(readmePath, "utf-8");
+        const limit = 1000;
+        return content.slice(0, limit) + (content.length > limit ? `
+...(truncated)...` : "");
+      } catch {
+        return "";
+      }
+    }
+    return "";
+  }
+  getProjectStructure() {
+    try {
+      const entries = import_node_fs4.readdirSync(this.projectPath);
+      const folders = entries.filter((e) => {
+        if (e.startsWith(".") || e === "node_modules")
+          return false;
+        try {
+          return import_node_fs4.statSync(import_node_path6.join(this.projectPath, e)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+      if (folders.length === 0)
+        return "";
+      let structure = `## Project Structure
+`;
+      structure += `Key directories in this project:
+`;
+      for (const folder of folders) {
+        structure += `- \`${folder}/\`
+`;
+      }
+      return `${structure}
+`;
+    } catch {
+      return "";
+    }
+  }
+  getSkillsInfo() {
+    const projectSkillsDirs = [
+      LOCUS_CONFIG.agentSkillsDir,
+      ".cursor/skills",
+      ".claude/skills",
+      ".codex/skills",
+      ".gemini/skills"
+    ];
+    const globalHome = import_node_os2.homedir();
+    const globalSkillsDirs = [
+      import_node_path6.join(globalHome, ".cursor/skills"),
+      import_node_path6.join(globalHome, ".claude/skills"),
+      import_node_path6.join(globalHome, ".codex/skills"),
+      import_node_path6.join(globalHome, ".gemini/skills")
+    ];
+    const allSkillNames = new Set;
+    for (const relativePath of projectSkillsDirs) {
+      const fullPath = import_node_path6.join(this.projectPath, relativePath);
+      this.scanSkillsInDirectory(fullPath, allSkillNames);
+    }
+    for (const fullPath of globalSkillsDirs) {
+      this.scanSkillsInDirectory(fullPath, allSkillNames);
+    }
+    const uniqueSkills = Array.from(allSkillNames).sort();
+    if (uniqueSkills.length === 0)
+      return "";
+    return `## Available Agent Skills
+` + `The project has the following specialized skills available (from project or global locations):
+` + uniqueSkills.map((s) => `- ${s}`).join(`
+`) + `
+
+`;
+  }
+  scanSkillsInDirectory(dirPath, skillSet) {
+    if (!import_node_fs4.existsSync(dirPath))
+      return;
+    try {
+      const entries = import_node_fs4.readdirSync(dirPath).filter((name) => {
+        try {
+          return import_node_fs4.statSync(import_node_path6.join(dirPath, name)).isDirectory();
+        } catch {
+          return false;
+        }
+      });
+      for (const entry of entries) {
+        skillSet.add(entry);
+      }
+    } catch {}
+  }
   roleToText(role) {
     if (!role) {
       return null;
     }
     switch (role) {
-      case import_shared2.AssigneeRole.BACKEND:
+      case import_shared3.AssigneeRole.BACKEND:
         return "Backend Engineer";
-      case import_shared2.AssigneeRole.FRONTEND:
+      case import_shared3.AssigneeRole.FRONTEND:
         return "Frontend Engineer";
-      case import_shared2.AssigneeRole.PM:
+      case import_shared3.AssigneeRole.PM:
         return "Product Manager";
-      case import_shared2.AssigneeRole.QA:
+      case import_shared3.AssigneeRole.QA:
         return "QA Engineer";
-      case import_shared2.AssigneeRole.DESIGN:
+      case import_shared3.AssigneeRole.DESIGN:
         return "Product Designer";
       default:
         return "engineer";
@@ -1259,18 +1506,11 @@ class TaskExecutor {
     this.deps = deps;
     this.promptBuilder = new PromptBuilder(deps.projectPath);
   }
-  updateSprintPlan(sprintPlan) {
-    this.deps.sprintPlan = sprintPlan;
-  }
-  async execute(task) {
+  async execute(task, context) {
     this.deps.log(`Executing: ${task.title}`, "info");
-    let basePrompt = await this.promptBuilder.build(task);
-    if (this.deps.sprintPlan) {
-      basePrompt = `## Sprint Context
-${this.deps.sprintPlan}
-
-${basePrompt}`;
-    }
+    const basePrompt = await this.promptBuilder.build(task, {
+      taskContext: context
+    });
     try {
       let plan = null;
       if (this.deps.skipPlanning) {
@@ -1329,16 +1569,14 @@ class AgentWorker {
   config;
   client;
   aiRunner;
-  sprintPlanner;
   indexerService;
   artifactSyncer;
   taskExecutor;
   consecutiveEmpty = 0;
-  maxEmpty = 5;
+  maxEmpty = 60;
   maxTasks = 50;
   tasksCompleted = 0;
   pollInterval = 1e4;
-  sprintPlan = null;
   constructor(config) {
     this.config = config;
     const projectPath = config.projectPath || process.cwd();
@@ -1359,10 +1597,6 @@ class AgentWorker {
       model: config.model,
       log
     });
-    this.sprintPlanner = new SprintPlanner({
-      aiRunner: this.aiRunner,
-      log
-    });
     this.indexerService = new CodebaseIndexerService({
       aiRunner: this.aiRunner,
       projectPath,
@@ -1377,7 +1611,6 @@ class AgentWorker {
     this.taskExecutor = new TaskExecutor({
       aiRunner: this.aiRunner,
       projectPath,
-      sprintPlan: null,
       skipPlanning: config.skipPlanning,
       log
     });
@@ -1416,8 +1649,13 @@ class AgentWorker {
   }
   async executeTask(task) {
     const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
-    this.taskExecutor.updateSprintPlan(this.sprintPlan);
-    const result = await this.taskExecutor.execute(fullTask);
+    let context = "";
+    try {
+      context = await this.client.tasks.getContext(task.id, this.config.workspaceId);
+    } catch (err) {
+      this.log(`Failed to fetch task context: ${err}`, "warn");
+    }
+    const result = await this.taskExecutor.execute(fullTask, context);
     await this.indexerService.reindex();
     return result;
   }
@@ -1425,35 +1663,12 @@ class AgentWorker {
     this.log(`Agent started in ${this.config.projectPath || process.cwd()}`, "success");
     const sprint = await this.getActiveSprint();
     if (sprint) {
-      this.log(`Found active sprint: ${sprint.name} (${sprint.id})`, "info");
-      const tasks2 = await this.client.tasks.list(this.config.workspaceId, {
-        sprintId: sprint.id
-      });
-      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) {
-            this.log("New tasks have been added to the sprint since last mindmap. Regenerating...", "warn");
-          }
-          this.sprintPlan = await this.sprintPlanner.planSprint(sprint, tasks2);
-          await this.client.sprints.update(sprint.id, this.config.workspaceId, {
-            mindmap: this.sprintPlan,
-            mindmapUpdatedAt: new Date
-          });
-        } else {
-          this.log("Using existing sprint mindmap.", "info");
-          this.sprintPlan = sprint.mindmap ?? null;
-        }
+      this.log(`Active sprint found: ${sprint.name}. Ensuring plan is up to date...`, "info");
+      try {
+        await this.client.sprints.triggerAIPlanning(sprint.id, this.config.workspaceId);
+        this.log(`Sprint plan sync checked on server.`, "success");
+      } catch (err) {
+        this.log(`Sprint planning sync failed (non-critical): ${err instanceof Error ? err.message : String(err)}`, "warn");
       }
     } else {
       this.log("No active sprint found for planning.", "warn");
@@ -1473,7 +1688,11 @@ class AgentWorker {
       this.consecutiveEmpty = 0;
       this.log(`Claimed: ${task.title}`, "success");
       const result = await this.executeTask(task);
-      await this.artifactSyncer.sync();
+      try {
+        await this.artifactSyncer.sync();
+      } catch (err) {
+        this.log(`Artifact sync failed: ${err}`, "error");
+      }
       if (result.success) {
         this.log(`Completed: ${task.title}`, "success");
         await this.client.tasks.update(task.id, this.config.workspaceId, {
@@ -1510,7 +1729,7 @@ if (process.argv[1]?.includes("agent-worker") || process.argv[1]?.includes("work
       config.workspaceId = args[++i];
     else if (arg === "--sprint-id")
       config.sprintId = args[++i];
-    else if (arg === "--api-base")
+    else if (arg === "--api-url")
       config.apiBase = args[++i];
     else if (arg === "--api-key")
       config.apiKey = args[++i];
@@ -1547,7 +1766,6 @@ __export(exports_index_node, {
   TasksModule: () => TasksModule,
   TaskExecutor: () => TaskExecutor,
   SprintsModule: () => SprintsModule,
-  SprintPlanner: () => SprintPlanner,
   PromptBuilder: () => PromptBuilder,
   PROVIDER: () => PROVIDER,
   OrganizationsModule: () => OrganizationsModule,
@@ -1566,13 +1784,14 @@ __export(exports_index_node, {
   AuthModule: () => AuthModule,
   ArtifactSyncer: () => ArtifactSyncer,
   AgentWorker: () => AgentWorker,
-  AgentOrchestrator: () => AgentOrchestrator
+  AgentOrchestrator: () => AgentOrchestrator,
+  AIModule: () => AIModule
 });
 module.exports = __toCommonJS(exports_index_node);
 // src/orchestrator.ts
 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_path7 = require("node:path");
 var import_node_url = require("node:url");
 var import_shared4 = require("@locusai/shared");
 var import_events3 = require("events");
@@ -1668,8 +1887,8 @@ ${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_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 currentModuleDir = import_node_path7.dirname(currentModulePath);
+    potentialPaths.push(import_node_path7.join(currentModuleDir, "agent", "worker.js"), import_node_path7.join(currentModuleDir, "worker.js"), import_node_path7.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.`);
@@ -1679,7 +1898,7 @@ ${c.success("✅ Orchestrator finished")}`);
       agentId,
       "--workspace-id",
       this.config.workspaceId,
-      "--api-base",
+      "--api-url",
       this.config.apiBase,
       "--api-key",
       this.config.apiKey,