@locusai/sdk 0.2.1

package/dist/agent/artifact-syncer.d.ts

@@ -0,0 +1,17 @@
+import type { LocusClient } from "../index";
+export interface ArtifactSyncerDeps {
+    client: LocusClient;
+    workspaceId: string;
+    projectPath: string;
+    log: (message: string, level?: "info" | "success" | "warn" | "error") => void;
+}
+/**
+ * Handles syncing local artifacts to the platform
+ */
+export declare class ArtifactSyncer {
+    private deps;
+    constructor(deps: ArtifactSyncerDeps);
+    private getOrCreateArtifactsGroup;
+    sync(): Promise<void>;
+}
+//# sourceMappingURL=artifact-syncer.d.ts.map

package/dist/agent/artifact-syncer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-syncer.d.ts","sourceRoot":"","sources":["../../src/agent/artifact-syncer.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC;CAC/E;AAED;;GAEG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,kBAAkB;YAE9B,yBAAyB;IA8BjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAwD5B"}

package/dist/agent/artifact-syncer.js

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { join } from "node:path";
+import { getLocusPath } from "../core/config";
+/**
+ * Handles syncing local artifacts to the platform
+ */
+export class ArtifactSyncer {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async getOrCreateArtifactsGroup() {
+        try {
+            const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
+            const artifactsGroup = groups.find((g) => g.name === "Artifacts");
+            if (artifactsGroup) {
+                return artifactsGroup.id;
+            }
+            // Create the Artifacts group
+            const newGroup = await this.deps.client.docs.createGroup(this.deps.workspaceId, {
+                name: "Artifacts",
+                order: 999, // Place at the end
+            });
+            this.deps.log("Created 'Artifacts' group for agent-generated docs", "info");
+            return newGroup.id;
+        }
+        catch (error) {
+            this.deps.log(`Failed to get/create Artifacts group: ${error}`, "error");
+            throw error;
+        }
+    }
+    async sync() {
+        const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
+        if (!existsSync(artifactsDir)) {
+            mkdirSync(artifactsDir, { recursive: true });
+            return;
+        }
+        try {
+            const files = readdirSync(artifactsDir);
+            if (files.length === 0)
+                return;
+            this.deps.log(`Syncing ${files.length} artifacts to server...`, "info");
+            // Get or create the Artifacts group
+            const artifactsGroupId = await this.getOrCreateArtifactsGroup();
+            // Get existing docs to check for updates
+            const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
+            for (const file of files) {
+                const filePath = join(artifactsDir, file);
+                if (statSync(filePath).isFile()) {
+                    const content = readFileSync(filePath, "utf-8");
+                    const title = file.replace(/\.md$/, "").trim();
+                    if (!title)
+                        continue;
+                    const existing = existingDocs.find((d) => d.title === title);
+                    if (existing) {
+                        if (existing.content !== content ||
+                            existing.groupId !== artifactsGroupId) {
+                            await this.deps.client.docs.update(existing.id, this.deps.workspaceId, { content, groupId: artifactsGroupId });
+                            this.deps.log(`Updated artifact: ${file}`, "success");
+                        }
+                    }
+                    else {
+                        await this.deps.client.docs.create(this.deps.workspaceId, {
+                            title,
+                            content,
+                            groupId: artifactsGroupId,
+                        });
+                        this.deps.log(`Created artifact: ${file}`, "success");
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.deps.log(`Failed to sync artifacts: ${error}`, "error");
+        }
+    }
+}

package/dist/agent/codebase-indexer-service.d.ts

@@ -0,0 +1,18 @@
+import type { AnthropicClient } from "../ai/anthropic-client";
+import type { ClaudeRunner } from "../ai/claude-runner";
+export interface CodebaseIndexerServiceDeps {
+    anthropicClient: AnthropicClient | null;
+    claudeRunner: ClaudeRunner;
+    projectPath: string;
+    log: (message: string, level?: "info" | "success" | "warn" | "error") => void;
+}
+/**
+ * Handles codebase indexing with AI analysis
+ */
+export declare class CodebaseIndexerService {
+    private deps;
+    private indexer;
+    constructor(deps: CodebaseIndexerServiceDeps);
+    reindex(): Promise<void>;
+}
+//# sourceMappingURL=codebase-indexer-service.d.ts.map

package/dist/agent/codebase-indexer-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codebase-indexer-service.d.ts","sourceRoot":"","sources":["../../src/agent/codebase-indexer-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,MAAM,WAAW,0BAA0B;IACzC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC;CAC/E;AAED;;GAEG;AACH,qBAAa,sBAAsB;IAGrB,OAAO,CAAC,IAAI;IAFxB,OAAO,CAAC,OAAO,CAAkB;gBAEb,IAAI,EAAE,0BAA0B;IAI9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAiD/B"}

package/dist/agent/codebase-indexer-service.js

@@ -0,0 +1,55 @@
+import { CodebaseIndexer } from "../core/indexer";
+/**
+ * Handles codebase indexing with AI analysis
+ */
+export class CodebaseIndexerService {
+    deps;
+    indexer;
+    constructor(deps) {
+        this.deps = deps;
+        this.indexer = new CodebaseIndexer(deps.projectPath);
+    }
+    async reindex() {
+        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
+2. Responsibilities of each directory/file
+3. Overall project structure
+
+Analyze this file tree and provide a JSON response with:
+- "symbols": object mapping symbol names to file paths (array)
+- "responsibilities": object mapping paths to brief descriptions
+
+File tree:
+${tree}
+
+Return ONLY valid JSON, no markdown formatting.`;
+                let response;
+                if (this.deps.anthropicClient) {
+                    // Use Anthropic SDK with caching for faster indexing
+                    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 {
+                    // Fallback to Claude CLI
+                    response = await this.deps.claudeRunner.run(prompt, true);
+                }
+                // Extract JSON from response (handle markdown code blocks)
+                const jsonMatch = response.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    return JSON.parse(jsonMatch[0]);
+                }
+                return { symbols: {}, responsibilities: {}, lastIndexed: "" };
+            });
+            this.indexer.saveIndex(index);
+            this.deps.log("Codebase reindexed successfully", "success");
+        }
+        catch (error) {
+            this.deps.log(`Failed to reindex codebase: ${error}`, "error");
+        }
+    }
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,6 @@
+export { ArtifactSyncer } from "./artifact-syncer";
+export { CodebaseIndexerService } from "./codebase-indexer-service";
+export { SprintPlanner } from "./sprint-planner";
+export { TaskExecutor } from "./task-executor";
+export { AgentWorker, type WorkerConfig } from "./worker";
+//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC"}

package/dist/agent/index.js

@@ -0,0 +1,5 @@
+export { ArtifactSyncer } from "./artifact-syncer";
+export { CodebaseIndexerService } from "./codebase-indexer-service";
+export { SprintPlanner } from "./sprint-planner";
+export { TaskExecutor } from "./task-executor";
+export { AgentWorker } from "./worker";

package/dist/agent/sprint-planner.d.ts

@@ -0,0 +1,17 @@
+import type { Sprint, Task } from "@locusai/shared";
+import type { AnthropicClient } from "../ai/anthropic-client";
+import type { ClaudeRunner } from "../ai/claude-runner";
+export interface SprintPlannerDeps {
+    anthropicClient: AnthropicClient | null;
+    claudeRunner: ClaudeRunner;
+    log: (message: string, level?: "info" | "success" | "warn" | "error") => void;
+}
+/**
+ * Handles sprint planning and mindmap generation
+ */
+export declare class SprintPlanner {
+    private deps;
+    constructor(deps: SprintPlannerDeps);
+    planSprint(sprint: Sprint, tasks: Task[]): Promise<string>;
+}
+//# sourceMappingURL=sprint-planner.d.ts.map

package/dist/agent/sprint-planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprint-planner.d.ts","sourceRoot":"","sources":["../../src/agent/sprint-planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC;CAC/E;AAED;;GAEG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,iBAAiB;IAErC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CA6DjE"}

package/dist/agent/sprint-planner.js

@@ -0,0 +1,62 @@
+/**
+ * Handles sprint planning and mindmap generation
+ */
+export class SprintPlanner {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async planSprint(sprint, tasks) {
+        this.deps.log(`Planning sprint: ${sprint.name}`, "info");
+        const taskList = tasks
+            .map((t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`)
+            .join("\n");
+        let plan;
+        if (this.deps.anthropicClient) {
+            // Use Anthropic SDK with caching for faster planning
+            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 {
+            // Fallback to Claude CLI
+            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.`;
+            plan = await this.deps.claudeRunner.run(planningPrompt, true);
+        }
+        this.deps.log("Sprint mindmap generated and posted to server.", "success");
+        return plan;
+    }
+}

package/dist/agent/task-executor.d.ts

@@ -0,0 +1,24 @@
+import type { Task } from "@locusai/shared";
+import type { AnthropicClient } from "../ai/anthropic-client";
+import type { ClaudeRunner } from "../ai/claude-runner";
+export interface TaskExecutorDeps {
+    anthropicClient: AnthropicClient | null;
+    claudeRunner: ClaudeRunner;
+    projectPath: string;
+    sprintPlan: string | null;
+    log: (message: string, level?: "info" | "success" | "warn" | "error") => void;
+}
+/**
+ * Handles task execution with two-phase approach (planning + execution)
+ */
+export declare class TaskExecutor {
+    private deps;
+    private promptBuilder;
+    constructor(deps: TaskExecutorDeps);
+    updateSprintPlan(sprintPlan: string | null): void;
+    execute(task: Task): Promise<{
+        success: boolean;
+        summary: string;
+    }>;
+}
+//# sourceMappingURL=task-executor.d.ts.map

package/dist/agent/task-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-executor.d.ts","sourceRoot":"","sources":["../../src/agent/task-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,KAAK,IAAI,CAAC;CAC/E;AAED;;GAEG;AACH,qBAAa,YAAY;IAGX,OAAO,CAAC,IAAI;IAFxB,OAAO,CAAC,aAAa,CAAgB;gBAEjB,IAAI,EAAE,gBAAgB;IAI1C,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIpC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAiD1E"}

package/dist/agent/task-executor.js

@@ -0,0 +1,56 @@
+import { PromptBuilder } from "../core/prompt-builder";
+/**
+ * Handles task execution with two-phase approach (planning + execution)
+ */
+export class TaskExecutor {
+    deps;
+    promptBuilder;
+    constructor(deps) {
+        this.deps = deps;
+        this.promptBuilder = new PromptBuilder(deps.projectPath);
+    }
+    updateSprintPlan(sprintPlan) {
+        this.deps.sprintPlan = sprintPlan;
+    }
+    async execute(task) {
+        this.deps.log(`Executing: ${task.title}`, "info");
+        let basePrompt = await this.promptBuilder.build(task);
+        if (this.deps.sprintPlan) {
+            basePrompt = `## Sprint Context\n${this.deps.sprintPlan}\n\n${basePrompt}`;
+        }
+        try {
+            let plan;
+            if (this.deps.anthropicClient) {
+                // Phase 1: Planning (using Anthropic SDK with caching)
+                this.deps.log("Phase 1: Planning (Anthropic SDK)...", "info");
+                // Build cacheable context blocks
+                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\nAnalyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.",
+                });
+            }
+            else {
+                // Phase 1: Planning (using Claude CLI)
+                this.deps.log("Phase 1: Planning (Claude CLI)...", "info");
+                const planningPrompt = `${basePrompt}\n\n## Phase 1: Planning\nAnalyze and create a detailed plan for THIS SPECIFIC TASK. Do NOT execute changes yet.`;
+                plan = await this.deps.claudeRunner.run(planningPrompt, true);
+            }
+            // Phase 2: Execution (always using Claude CLI for agentic tools)
+            this.deps.log("Plan generated. Starting Phase 2: Execution...", "info");
+            const executionPrompt = `${basePrompt}\n\n## Phase 2: Execution\nBased on the plan, execute the task:\n\n${plan}\n\nWhen finished, output: <promise>COMPLETE</promise>`;
+            const output = await this.deps.claudeRunner.run(executionPrompt);
+            const success = output.includes("<promise>COMPLETE</promise>");
+            return {
+                success,
+                summary: success
+                    ? "Task completed by Claude"
+                    : "Claude did not signal completion",
+            };
+        }
+        catch (error) {
+            return { success: false, summary: `Error: ${error}` };
+        }
+    }
+}

package/dist/agent/worker.d.ts

@@ -0,0 +1,37 @@
+export interface WorkerConfig {
+    agentId: string;
+    workspaceId: string;
+    sprintId?: string;
+    apiBase: string;
+    projectPath: string;
+    apiKey: string;
+    anthropicApiKey?: string;
+    model?: string;
+}
+/**
+ * Main agent worker that orchestrates task execution
+ * Delegates responsibilities to specialized services
+ */
+export declare class AgentWorker {
+    private config;
+    private client;
+    private claudeRunner;
+    private anthropicClient;
+    private sprintPlanner;
+    private indexerService;
+    private artifactSyncer;
+    private taskExecutor;
+    private consecutiveEmpty;
+    private maxEmpty;
+    private maxTasks;
+    private tasksCompleted;
+    private pollInterval;
+    private sprintPlan;
+    constructor(config: WorkerConfig);
+    log(message: string, level?: "info" | "success" | "warn" | "error"): void;
+    private getActiveSprint;
+    private getNextTask;
+    private executeTask;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=worker.d.ts.map

package/dist/agent/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/agent/worker.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,qBAAa,WAAW;IAmBV,OAAO,CAAC,MAAM;IAlB1B,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,eAAe,CAAyB;IAGhD,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IAGnC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,UAAU,CAAuB;gBAErB,MAAM,EAAE,YAAY;IA+DxC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,OAAgB;YAQ5D,eAAe;YAcf,WAAW;YAiBX,WAAW;IAqBnB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA+F3B"}

package/dist/agent/worker.js

@@ -0,0 +1,232 @@
+import { AnthropicClient } from "../ai/anthropic-client";
+import { ClaudeRunner } from "../ai/claude-runner";
+import { LocusClient } from "../index";
+import { ArtifactSyncer } from "./artifact-syncer";
+import { CodebaseIndexerService } from "./codebase-indexer-service";
+import { SprintPlanner } from "./sprint-planner";
+import { TaskExecutor } from "./task-executor";
+/**
+ * Main agent worker that orchestrates task execution
+ * Delegates responsibilities to specialized services
+ */
+export class AgentWorker {
+    config;
+    client;
+    claudeRunner;
+    anthropicClient;
+    // Services
+    sprintPlanner;
+    indexerService;
+    artifactSyncer;
+    taskExecutor;
+    // State
+    consecutiveEmpty = 0;
+    maxEmpty = 10;
+    maxTasks = 50;
+    tasksCompleted = 0;
+    pollInterval = 10_000;
+    sprintPlan = null;
+    constructor(config) {
+        this.config = config;
+        const projectPath = config.projectPath || process.cwd();
+        // Initialize API client
+        this.client = new LocusClient({
+            baseUrl: config.apiBase,
+            token: config.apiKey,
+        });
+        // Initialize AI clients
+        this.claudeRunner = new ClaudeRunner(projectPath, config.model);
+        this.anthropicClient = config.anthropicApiKey
+            ? new AnthropicClient({
+                apiKey: config.anthropicApiKey,
+                model: config.model,
+            })
+            : null;
+        // Initialize services with dependencies
+        const logFn = this.log.bind(this);
+        this.sprintPlanner = new SprintPlanner({
+            anthropicClient: this.anthropicClient,
+            claudeRunner: this.claudeRunner,
+            log: logFn,
+        });
+        this.indexerService = new CodebaseIndexerService({
+            anthropicClient: this.anthropicClient,
+            claudeRunner: this.claudeRunner,
+            projectPath,
+            log: logFn,
+        });
+        this.artifactSyncer = new ArtifactSyncer({
+            client: this.client,
+            workspaceId: config.workspaceId,
+            projectPath,
+            log: logFn,
+        });
+        this.taskExecutor = new TaskExecutor({
+            anthropicClient: this.anthropicClient,
+            claudeRunner: this.claudeRunner,
+            projectPath,
+            sprintPlan: null, // Will be set after sprint planning
+            log: logFn,
+        });
+        // Log initialization
+        if (this.anthropicClient) {
+            this.log("Using Anthropic SDK with prompt caching for planning phases", "info");
+        }
+        else {
+            this.log("Using Claude CLI for all phases (no Anthropic API key provided)", "info");
+        }
+    }
+    log(message, level = "info") {
+        const timestamp = new Date().toISOString().split("T")[1]?.slice(0, 8) ?? "";
+        const prefix = { info: "ℹ", success: "✓", warn: "⚠", error: "✗" }[level];
+        console.log(`[${timestamp}] [${this.config.agentId.slice(-8)}] ${prefix} ${message}`);
+    }
+    async getActiveSprint() {
+        try {
+            if (this.config.sprintId) {
+                return await this.client.sprints.getById(this.config.sprintId, this.config.workspaceId);
+            }
+            return await this.client.sprints.getActive(this.config.workspaceId);
+        }
+        catch (_error) {
+            return null;
+        }
+    }
+    async getNextTask() {
+        try {
+            const task = await this.client.workspaces.dispatch(this.config.workspaceId, this.config.agentId, this.config.sprintId);
+            return task;
+        }
+        catch (error) {
+            this.log(`No task dispatched: ${error instanceof Error ? error.message : String(error)}`, "info");
+            return null;
+        }
+    }
+    async executeTask(task) {
+        // Reindex codebase before execution to ensure fresh context
+        await this.indexerService.reindex();
+        // Fetch full task details to get comments/feedback
+        const fullTask = await this.client.tasks.getById(task.id, this.config.workspaceId);
+        // Update task executor with current sprint plan
+        this.taskExecutor.updateSprintPlan(this.sprintPlan);
+        // Execute the task
+        const result = await this.taskExecutor.execute(fullTask);
+        return result;
+    }
+    async run() {
+        this.log(`Agent started in ${this.config.projectPath || process.cwd()}`, "success");
+        // Initial Sprint Planning Phase
+        const sprint = await this.getActiveSprint();
+        if (sprint) {
+            this.log(`Found active sprint: ${sprint.name} (${sprint.id})`, "info");
+            const tasks = await this.client.tasks.list(this.config.workspaceId, {
+                sprintId: sprint.id,
+            });
+            this.log(`Sprint tasks found: ${tasks.length}`, "info");
+            const latestTaskCreation = tasks.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, tasks);
+                // Save mindmap to server
+                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;
+            }
+        }
+        else {
+            this.log("No active sprint found for planning.", "warn");
+        }
+        // Main task execution loop
+        while (this.tasksCompleted < this.maxTasks &&
+            this.consecutiveEmpty < this.maxEmpty) {
+            const task = await this.getNextTask();
+            if (!task) {
+                this.consecutiveEmpty++;
+                if (this.consecutiveEmpty >= this.maxEmpty)
+                    break;
+                await new Promise((r) => setTimeout(r, this.pollInterval));
+                continue;
+            }
+            this.consecutiveEmpty = 0;
+            this.log(`Claimed: ${task.title}`, "success");
+            const result = await this.executeTask(task);
+            // Sync artifacts after task execution
+            await this.artifactSyncer.sync();
+            if (result.success) {
+                await this.client.tasks.update(task.id, this.config.workspaceId, {
+                    status: "VERIFICATION",
+                });
+                await this.client.tasks.addComment(task.id, this.config.workspaceId, {
+                    author: this.config.agentId,
+                    text: `✅ ${result.summary}`,
+                });
+                this.tasksCompleted++;
+            }
+            else {
+                await this.client.tasks.update(task.id, this.config.workspaceId, {
+                    status: "BACKLOG",
+                    assignedTo: null,
+                });
+                await this.client.tasks.addComment(task.id, this.config.workspaceId, {
+                    author: this.config.agentId,
+                    text: `❌ ${result.summary}`,
+                });
+            }
+        }
+        process.exit(0);
+    }
+}
+// CLI entry point
+if (process.argv[1]?.includes("agent-worker") ||
+    process.argv[1]?.includes("worker")) {
+    const args = process.argv.slice(2);
+    const config = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--agent-id")
+            config.agentId = args[++i];
+        else if (arg === "--workspace-id")
+            config.workspaceId = args[++i];
+        else if (arg === "--sprint-id")
+            config.sprintId = args[++i];
+        else if (arg === "--api-base")
+            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];
+    }
+    if (!config.agentId ||
+        !config.workspaceId ||
+        !config.apiBase ||
+        !config.apiKey ||
+        !config.projectPath) {
+        console.error("Missing required arguments");
+        process.exit(1);
+    }
+    const worker = new AgentWorker(config);
+    worker.run().catch((err) => {
+        console.error("Fatal worker error:", err);
+        process.exit(1);
+    });
+}