@locusai/sdk 0.4.6 → 0.4.10

package/dist/utils/retry.js

@@ -1,37 +0,0 @@
-import { isAxiosError } from "axios";
-export const DEFAULT_RETRY_OPTIONS = {
-    maxRetries: 3,
-    initialDelay: 1000,
-    maxDelay: 5000,
-    factor: 2,
-    retryCondition: (error) => {
-        // Retry on network errors or 5xx server errors
-        if (isAxiosError(error)) {
-            if (!error.response)
-                return true; // Network error
-            return error.response.status >= 500;
-        }
-        return true; // Retry on other unknown errors
-    },
-};
-/**
- * Retries an async function with exponential backoff
- */
-export async function withRetry(fn, options = {}) {
-    const config = { ...DEFAULT_RETRY_OPTIONS, ...options };
-    let lastError;
-    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt === config.maxRetries || !config.retryCondition(error)) {
-                throw error;
-            }
-            const delay = Math.min(config.initialDelay * Math.pow(config.factor, attempt), config.maxDelay);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-    }
-    throw lastError;
-}

package/src/agent/artifact-syncer.ts

@@ -1,111 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-} from "node:fs";
-import { join } from "node:path";
-import { getLocusPath } from "../core/config.js";
-import type { LocusClient } from "../index.js";
-
-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 class ArtifactSyncer {
-  constructor(private deps: ArtifactSyncerDeps) {}
-
-  private async getOrCreateArtifactsGroup(): Promise<string> {
-    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(): Promise<void> {
-    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/src/agent/codebase-indexer-service.ts

@@ -1,71 +0,0 @@
-import type { AnthropicClient } from "../ai/anthropic-client.js";
-import type { ClaudeRunner } from "../ai/claude-runner.js";
-import { CodebaseIndexer } from "../core/indexer.js";
-
-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 class CodebaseIndexerService {
-  private indexer: CodebaseIndexer;
-
-  constructor(private deps: CodebaseIndexerServiceDeps) {
-    this.indexer = new CodebaseIndexer(deps.projectPath);
-  }
-
-  async reindex(): Promise<void> {
-    try {
-      this.deps.log("Reindexing codebase...", "info");
-
-      const index = await this.indexer.index(
-        (msg) => this.deps.log(msg, "info"),
-        async (tree: string) => {
-          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: string;
-
-          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/src/agent/index.ts

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

package/src/agent/sprint-planner.ts

@@ -1,86 +0,0 @@
-import type { Sprint, Task } from "@locusai/shared";
-import type { AnthropicClient } from "../ai/anthropic-client.js";
-import type { ClaudeRunner } from "../ai/claude-runner.js";
-
-export interface SprintPlannerDeps {
-  anthropicClient: AnthropicClient | null;
-  claudeRunner: ClaudeRunner;
-  log: (message: string, level?: "info" | "success" | "warn" | "error") => void;
-}
-
-/**
- * Handles sprint planning and mindmap generation
- */
-export class SprintPlanner {
-  constructor(private deps: SprintPlannerDeps) {}
-
-  async planSprint(sprint: Sprint, tasks: Task[]): Promise<string> {
-    this.deps.log(`Planning sprint: ${sprint.name}`, "info");
-
-    try {
-      const taskList = tasks
-        .map(
-          (t) => `- [${t.id}] ${t.title}: ${t.description || "No description"}`
-        )
-        .join("\n");
-
-      let plan: string;
-
-      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;
-    } catch (error) {
-      this.deps.log(`Sprint planning failed: ${error}`, "error");
-      return sprint.mindmap || "";
-    }
-  }
-}

package/src/agent/task-executor.ts

@@ -1,85 +0,0 @@
-import type { Task } from "@locusai/shared";
-import type { AnthropicClient } from "../ai/anthropic-client.js";
-import type { ClaudeRunner } from "../ai/claude-runner.js";
-import { PromptBuilder } from "../core/prompt-builder.js";
-
-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 class TaskExecutor {
-  private promptBuilder: PromptBuilder;
-
-  constructor(private deps: TaskExecutorDeps) {
-    this.promptBuilder = new PromptBuilder(deps.projectPath);
-  }
-
-  updateSprintPlan(sprintPlan: string | null) {
-    this.deps.sprintPlan = sprintPlan;
-  }
-
-  async execute(task: Task): Promise<{ success: boolean; summary: string }> {
-    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: string = "";
-
-      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: string[] = [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 {
-        this.deps.log(
-          "Skipping Phase 1: Planning (No Anthropic API Key)...",
-          "info"
-        );
-      }
-
-      // Phase 2: Execution (always using Claude CLI for agentic tools)
-      this.deps.log("Starting Execution...", "info");
-
-      let executionPrompt = basePrompt;
-      if (plan) {
-        executionPrompt += `\n\n## Phase 2: Execution\nBased on the plan, execute the task:\n\n${plan}`;
-      } else {
-        executionPrompt += `\n\n## Execution\nExecute the task directly.`;
-      }
-
-      executionPrompt += `\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}` };
-    }
-  }
-}