@locusai/sdk 0.5.0 → 0.6.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,6 +86,28 @@ class BaseModule {
   }
 }
 
+// src/modules/ai.ts
+class AIModule extends BaseModule {
+  async chat(workspaceId, body) {
+    const { data } = await this.api.post(`/ai/${workspaceId}/chat`, body);
+    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() {
@@ -248,6 +271,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 +321,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
@@ -347,6 +384,7 @@ class LocusClient {
   api;
   emitter;
   auth;
+  ai;
   tasks;
   sprints;
   workspaces;
@@ -358,7 +396,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 +404,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 +478,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 +494,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") {
@@ -623,12 +663,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?.(`
 
@@ -715,7 +751,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 +823,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 +855,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 +880,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");
     }
@@ -847,6 +916,7 @@ class ArtifactSyncer {
 }
 
 // src/core/indexer.ts
+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");
@@ -854,16 +924,64 @@ var import_globby = require("globby");
 class CodebaseIndexer {
   projectPath;
   indexPath;
+  fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
     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...");
+    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_fs3.existsSync(gitmodulesPath)) {
@@ -881,7 +999,7 @@ class CodebaseIndexer {
         }
       } catch {}
     }
-    const files = await import_globby.globby(["**/*"], {
+    return import_globby.globby(["**/*"], {
       cwd: this.projectPath,
       gitignore: true,
       ignore: [
@@ -922,13 +1040,6 @@ 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_fs3.existsSync(this.indexPath)) {
@@ -947,6 +1058,79 @@ class CodebaseIndexer {
     }
     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;
+    }
+  }
+  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);
+  }
 }
 
 // src/agent/codebase-indexer-service.ts
@@ -957,9 +1141,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
@@ -980,7 +1163,11 @@ Return ONLY valid JSON, no markdown formatting.`;
           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) {
@@ -989,53 +1176,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}
 
 `;
@@ -1050,18 +1201,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
@@ -1070,11 +1284,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)...` : ""}
 
 `;
       }
@@ -1090,7 +1312,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:
@@ -1112,20 +1334,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";
@@ -1141,18 +1465,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) {
@@ -1211,16 +1528,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();
@@ -1241,10 +1556,6 @@ class AgentWorker {
       model: config.model,
       log
     });
-    this.sprintPlanner = new SprintPlanner({
-      aiRunner: this.aiRunner,
-      log
-    });
     this.indexerService = new CodebaseIndexerService({
       aiRunner: this.aiRunner,
       projectPath,
@@ -1259,7 +1570,6 @@ class AgentWorker {
     this.taskExecutor = new TaskExecutor({
       aiRunner: this.aiRunner,
       projectPath,
-      sprintPlan: null,
       skipPlanning: config.skipPlanning,
       log
     });
@@ -1298,8 +1608,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;
   }
@@ -1307,35 +1622,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");
@@ -1355,7 +1647,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, {
@@ -1392,7 +1688,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];
@@ -1429,7 +1725,6 @@ __export(exports_index_node, {
   TasksModule: () => TasksModule,
   TaskExecutor: () => TaskExecutor,
   SprintsModule: () => SprintsModule,
-  SprintPlanner: () => SprintPlanner,
   PromptBuilder: () => PromptBuilder,
   PROVIDER: () => PROVIDER,
   OrganizationsModule: () => OrganizationsModule,
@@ -1448,13 +1743,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");
@@ -1550,8 +1846,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.`);
@@ -1561,7 +1857,7 @@ ${c.success("✅ Orchestrator finished")}`);
       agentId,
       "--workspace-id",
       this.config.workspaceId,
-      "--api-base",
+      "--api-url",
       this.config.apiBase,
       "--api-key",
       this.config.apiKey,