ashlrcode 1.0.0

package/src/agent/sub-agent.ts

@@ -0,0 +1,125 @@
+/**
+ * Sub-agent — spawn child agents with isolated message context.
+ *
+ * Pattern from Claude Code's AgentTool:
+ * - Fresh messages[] per child agent
+ * - Shared tool registry and provider router
+ * - Results returned to parent
+ */
+
+import type { ProviderRouter } from "../providers/router.ts";
+import type { ToolRegistry } from "../tools/registry.ts";
+import type { ToolContext } from "../tools/types.ts";
+import type { Message } from "../providers/types.ts";
+import { runAgentLoop } from "./loop.ts";
+import { createWorktree, removeWorktree } from "./worktree-manager.ts";
+import { runWithAgentContext, createChildContext, getAgentContext } from "./async-context.ts";
+
+export interface SubAgentConfig {
+  name: string;
+  prompt: string;
+  systemPrompt: string;
+  router: ProviderRouter;
+  toolRegistry: ToolRegistry;
+  toolContext: ToolContext;
+  /** Only allow read-only tools */
+  readOnly?: boolean;
+  /** Execution mode: in-process (default) or worktree-isolated */
+  mode?: "in_process" | "worktree";
+  /** Max iterations for this sub-agent */
+  maxIterations?: number;
+  /** Callback for streaming text */
+  onText?: (text: string) => void;
+  /** Callback for tool events */
+  onToolStart?: (name: string, input: Record<string, unknown>) => void;
+  onToolEnd?: (name: string, result: string, isError: boolean) => void;
+}
+
+export interface SubAgentResult {
+  name: string;
+  text: string;
+  toolCalls: Array<{ name: string; input: Record<string, unknown>; result: string }>;
+  messages: Message[];
+  worktree?: { path: string; branch: string };
+}
+
+/**
+ * Run a sub-agent in an isolated git worktree.
+ * The worktree is created before the agent runs and preserved after
+ * so the parent can inspect or merge the branch. On error, the
+ * worktree is cleaned up automatically.
+ */
+async function runWorktreeSubAgent(config: SubAgentConfig): Promise<SubAgentResult> {
+  const wt = await createWorktree(config.name);
+  const worktreeContext: ToolContext = { ...config.toolContext, cwd: wt.path };
+
+  const parentCtx = getAgentContext();
+  const childCtx = createChildContext(parentCtx, config.name, wt.path, config.readOnly ?? true);
+
+  return runWithAgentContext(childCtx, async () => {
+    try {
+      const result = await runAgentLoop(config.prompt, [], {
+        systemPrompt: config.systemPrompt,
+        router: config.router,
+        toolRegistry: config.toolRegistry,
+        toolContext: worktreeContext,
+        readOnly: config.readOnly,
+        maxIterations: config.maxIterations ?? 15,
+        onText: config.onText,
+        onToolStart: config.onToolStart,
+        onToolEnd: config.onToolEnd,
+      });
+
+      return {
+        name: config.name,
+        text: result.finalText,
+        toolCalls: result.toolCalls,
+        messages: result.messages,
+        worktree: { path: wt.path, branch: wt.branch },
+      };
+    } catch (err) {
+      await removeWorktree(wt.path).catch(() => {});
+      throw err;
+    }
+  });
+}
+
+/**
+ * Run a sub-agent with its own fresh message context.
+ */
+export async function runSubAgent(config: SubAgentConfig): Promise<SubAgentResult> {
+  if (config.mode === "worktree") return runWorktreeSubAgent(config);
+
+  const parentCtx = getAgentContext();
+  const childCtx = createChildContext(parentCtx, config.name, config.toolContext.cwd, config.readOnly ?? true);
+
+  return runWithAgentContext(childCtx, async () => {
+    const result = await runAgentLoop(config.prompt, [], {
+      systemPrompt: config.systemPrompt,
+      router: config.router,
+      toolRegistry: config.toolRegistry,
+      toolContext: config.toolContext,
+      readOnly: config.readOnly,
+      maxIterations: config.maxIterations ?? 15,
+      onText: config.onText,
+      onToolStart: config.onToolStart,
+      onToolEnd: config.onToolEnd,
+    });
+
+    return {
+      name: config.name,
+      text: result.finalText,
+      toolCalls: result.toolCalls,
+      messages: result.messages,
+    };
+  });
+}
+
+/**
+ * Run multiple sub-agents in parallel.
+ */
+export async function runSubAgentsParallel(
+  configs: SubAgentConfig[]
+): Promise<SubAgentResult[]> {
+  return Promise.all(configs.map(runSubAgent));
+}

package/src/agent/system-prompt.ts

@@ -0,0 +1,231 @@
+/**
+ * Dynamic System Prompt Assembly — builds prompts from parts.
+ *
+ * Pattern from Claude Code: prompt is assembled at query time from
+ * core instructions + tool schemas + permissions + project config + knowledge files.
+ */
+
+import { existsSync } from "fs";
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+import { getModelPatches } from "./model-patches.ts";
+import { getUndercoverPrompt } from "../config/undercover.ts";
+import type { ToolRegistry } from "../tools/registry.ts";
+
+export interface PromptPart {
+  name: string;
+  content: string;
+  priority: number; // Lower = earlier in prompt
+}
+
+export interface AssembledPrompt {
+  text: string;
+  parts: string[]; // Names of included parts
+  estimatedTokens: number; // Rough token count
+}
+
+/**
+ * Estimate tokens from text (rough: chars / 4).
+ */
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+export class SystemPromptBuilder {
+  private parts: PromptPart[] = [];
+
+  /** Add a named section to the prompt */
+  addPart(name: string, content: string, priority: number = 50): this {
+    this.parts.push({ name, content, priority });
+    return this;
+  }
+
+  /** Add core instructions */
+  addCoreInstructions(instructions: string): this {
+    return this.addPart("core", instructions, 0);
+  }
+
+  /** Add tool descriptions from registry */
+  addToolDescriptions(registry: ToolRegistry, readOnly: boolean = false): this {
+    const tools = readOnly
+      ? registry.getAll().filter((t) => t.isReadOnly())
+      : registry.getAll();
+    const descriptions = tools
+      .map((t) => `### ${t.name}\n${t.prompt()}`)
+      .join("\n\n");
+    return this.addPart("tools", `## Available Tools\n\n${descriptions}`, 10);
+  }
+
+  /** Add permission context */
+  addPermissionContext(mode: string, rules?: string): this {
+    let content = `## Permissions\nCurrent mode: ${mode}`;
+    if (rules) content += `\nRules:\n${rules}`;
+    return this.addPart("permissions", content, 20);
+  }
+
+  /** Load and add knowledge files (CLAUDE.md equivalent) from project dir */
+  async addKnowledgeFiles(projectDir: string): Promise<this> {
+    const knowledgeDir = join(projectDir, ".ashlrcode");
+    if (!existsSync(knowledgeDir)) return this;
+
+    try {
+      const files = await readdir(knowledgeDir);
+      for (const file of files) {
+        if (!file.endsWith(".md")) continue;
+        const content = await readFile(join(knowledgeDir, file), "utf-8");
+        this.addPart(
+          `knowledge:${file}`,
+          `## Project Knowledge: ${file}\n\n${content}`,
+          30
+        );
+      }
+    } catch {
+      // Knowledge dir unreadable — skip silently
+    }
+
+    return this;
+  }
+
+  /** Load and add memory files */
+  async addMemoryFiles(): Promise<this> {
+    const memoryDir = join(getConfigDir(), "memory");
+    if (!existsSync(memoryDir)) return this;
+
+    try {
+      const files = await readdir(memoryDir);
+      const memories: string[] = [];
+      for (const file of files) {
+        if (!file.endsWith(".md") || file === "index.md") continue;
+        const content = await readFile(join(memoryDir, file), "utf-8");
+        memories.push(content.trim());
+      }
+      if (memories.length > 0) {
+        this.addPart(
+          "memory",
+          `## Memory\n\n${memories.join("\n\n---\n\n")}`,
+          40
+        );
+      }
+    } catch {
+      // Memory dir unreadable — skip silently
+    }
+
+    return this;
+  }
+
+  /** Add plan mode instructions */
+  addPlanMode(planFile?: string): this {
+    let content =
+      "## Plan Mode Active\nYou are in read-only plan mode. Only use read-only tools.";
+    if (planFile) content += `\nPlan file: ${planFile}`;
+    return this.addPart("plan-mode", content, 5);
+  }
+
+  /** Add custom section */
+  addSection(name: string, content: string, priority?: number): this {
+    return this.addPart(name, content, priority ?? 50);
+  }
+
+  /** Add git context (branch, recent commits, working tree status) */
+  async addGitContext(cwd: string): Promise<this> {
+    const { isGitRepo, getCurrentBranch, getRecentCommits, getGitStatus } = await import("../config/git.ts");
+    if (!await isGitRepo(cwd)) return this;
+
+    const branch = await getCurrentBranch(cwd);
+    const commits = await getRecentCommits(cwd, 3);
+    const status = await getGitStatus(cwd);
+
+    let context = `## Git Context\nBranch: ${branch ?? "unknown"}`;
+    if (commits.length > 0) context += `\nRecent commits:\n${commits.map(c => `  ${c}`).join("\n")}`;
+    if (status.modified + status.untracked > 0) {
+      context += `\nWorking tree: ${status.modified} modified, ${status.untracked} untracked`;
+    }
+
+    return this.addPart("git", context, 35);
+  }
+
+  /** Add model-specific behavior patches */
+  addModelPatches(modelName: string): this {
+    const { combinedSuffix } = getModelPatches(modelName);
+    if (combinedSuffix) this.addPart("model-patches", combinedSuffix, 90);
+    return this;
+  }
+
+  /** Add undercover mode prompt if active */
+  addUndercoverPrompt(): this {
+    const prompt = getUndercoverPrompt();
+    if (prompt) this.addPart("undercover", prompt, 95);
+    return this;
+  }
+
+  /** Build the final prompt, respecting a token budget */
+  build(maxTokens?: number): AssembledPrompt {
+    // Sort by priority (lower = earlier / more important)
+    const sorted = [...this.parts].sort((a, b) => a.priority - b.priority);
+
+    const included: PromptPart[] = [];
+    let totalTokens = 0;
+
+    for (const part of sorted) {
+      const partTokens = estimateTokens(part.content);
+      if (maxTokens && totalTokens + partTokens > maxTokens) {
+        continue; // Skip parts that would exceed budget
+      }
+      included.push(part);
+      totalTokens += partTokens;
+    }
+
+    const text = included.map((p) => p.content).join("\n\n");
+
+    return {
+      text,
+      parts: included.map((p) => p.name),
+      estimatedTokens: totalTokens,
+    };
+  }
+
+  /** Reset for fresh assembly */
+  reset(): this {
+    this.parts = [];
+    return this;
+  }
+}
+
+/**
+ * Convenience: build a standard system prompt with all common parts.
+ */
+export async function buildSystemPrompt(options: {
+  coreInstructions: string;
+  toolRegistry: ToolRegistry;
+  readOnly?: boolean;
+  mode?: string;
+  projectDir?: string;
+  planFile?: string;
+  modelName?: string;
+  maxTokens?: number;
+}): Promise<AssembledPrompt> {
+  const builder = new SystemPromptBuilder();
+
+  builder.addCoreInstructions(options.coreInstructions);
+  builder.addToolDescriptions(options.toolRegistry, options.readOnly);
+  builder.addPermissionContext(options.mode ?? "normal");
+
+  if (options.readOnly && options.planFile) {
+    builder.addPlanMode(options.planFile);
+  }
+
+  if (options.projectDir) {
+    await builder.addKnowledgeFiles(options.projectDir);
+  }
+
+  await builder.addMemoryFiles();
+
+  if (options.modelName) {
+    builder.addModelPatches(options.modelName);
+  }
+
+  builder.addUndercoverPrompt();
+
+  return builder.build(options.maxTokens);
+}

package/src/agent/team.ts

@@ -0,0 +1,220 @@
+/**
+ * Team Persistence — manage persistent agent teammates.
+ *
+ * Pattern from Claude Code's coordinator mode: a lead agent can create
+ * teammates that persist across sessions, claim tasks from a shared
+ * board, and report results back.
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, readdir, mkdir, unlink } from "fs/promises";
+import { join } from "path";
+import { getConfigDir } from "../config/settings.ts";
+
+export interface Teammate {
+  id: string;
+  name: string;
+  role: string; // e.g., "code-reviewer", "test-writer", "explorer"
+  systemPrompt: string; // Specialized instructions for this teammate
+  createdAt: string;
+  lastActiveAt?: string;
+  stats: {
+    tasksCompleted: number;
+    totalIterations: number;
+  };
+}
+
+export interface Team {
+  id: string;
+  name: string;
+  teammates: Teammate[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+function getTeamsDir(): string {
+  return join(getConfigDir(), "teams");
+}
+
+function getTeamPath(teamId: string): string {
+  return join(getTeamsDir(), `${teamId}.json`);
+}
+
+/**
+ * Create a new team.
+ */
+export async function createTeam(name: string): Promise<Team> {
+  await mkdir(getTeamsDir(), { recursive: true });
+
+  const team: Team = {
+    id: `team-${Date.now()}`,
+    name,
+    teammates: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  await saveTeam(team);
+  return team;
+}
+
+/**
+ * Add a teammate to a team.
+ */
+export async function addTeammate(
+  teamId: string,
+  name: string,
+  role: string,
+  systemPrompt?: string,
+): Promise<Teammate> {
+  const team = await loadTeam(teamId);
+  if (!team) throw new Error(`Team ${teamId} not found`);
+
+  const rolePrompts: Record<string, string> = {
+    "code-reviewer":
+      "You are a code reviewer. Focus on bugs, logic errors, security vulnerabilities, and code quality. Be thorough but only flag high-confidence issues.",
+    "test-writer":
+      "You are a test writer. Write comprehensive tests for the code you're given. Cover edge cases, error scenarios, and happy paths.",
+    explorer:
+      "You are a codebase explorer. Map patterns, find dependencies, and report findings with specific file paths and line numbers.",
+    implementer:
+      "You are an implementer. Write clean, well-structured code that follows the existing patterns and conventions in the codebase.",
+  };
+
+  const teammate: Teammate = {
+    id: `mate-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    name,
+    role,
+    systemPrompt: systemPrompt ?? rolePrompts[role] ?? `You are a ${role}.`,
+    createdAt: new Date().toISOString(),
+    stats: { tasksCompleted: 0, totalIterations: 0 },
+  };
+
+  team.teammates.push(teammate);
+  team.updatedAt = new Date().toISOString();
+  await saveTeam(team);
+
+  return teammate;
+}
+
+/**
+ * Remove a teammate from a team.
+ */
+export async function removeTeammate(
+  teamId: string,
+  teammateId: string,
+): Promise<boolean> {
+  const team = await loadTeam(teamId);
+  if (!team) return false;
+
+  const idx = team.teammates.findIndex((t) => t.id === teammateId);
+  if (idx === -1) return false;
+
+  team.teammates.splice(idx, 1);
+  team.updatedAt = new Date().toISOString();
+  await saveTeam(team);
+  return true;
+}
+
+/**
+ * Record teammate activity.
+ */
+export async function recordTeammateActivity(
+  teamId: string,
+  teammateId: string,
+  tasksCompleted: number = 1,
+  iterations: number = 0,
+): Promise<void> {
+  const team = await loadTeam(teamId);
+  if (!team) return;
+
+  const mate = team.teammates.find((t) => t.id === teammateId);
+  if (!mate) return;
+
+  mate.stats.tasksCompleted += tasksCompleted;
+  mate.stats.totalIterations += iterations;
+  mate.lastActiveAt = new Date().toISOString();
+  team.updatedAt = new Date().toISOString();
+  await saveTeam(team);
+}
+
+/**
+ * Load a team by ID.
+ */
+export async function loadTeam(teamId: string): Promise<Team | null> {
+  const path = getTeamPath(teamId);
+  if (!existsSync(path)) return null;
+
+  try {
+    const raw = await readFile(path, "utf-8");
+    return JSON.parse(raw) as Team;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List all teams.
+ */
+export async function listTeams(): Promise<Team[]> {
+  const dir = getTeamsDir();
+  if (!existsSync(dir)) return [];
+
+  const files = await readdir(dir);
+  const teams: Team[] = [];
+
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      teams.push(JSON.parse(raw) as Team);
+    } catch {
+      // Skip corrupt team files
+    }
+  }
+
+  return teams.sort(
+    (a, b) =>
+      new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
+  );
+}
+
+/**
+ * Delete a team.
+ */
+export async function deleteTeam(teamId: string): Promise<boolean> {
+  const path = getTeamPath(teamId);
+  if (!existsSync(path)) return false;
+
+  await unlink(path);
+  return true;
+}
+
+/**
+ * Save team to disk.
+ */
+async function saveTeam(team: Team): Promise<void> {
+  await mkdir(getTeamsDir(), { recursive: true });
+  await writeFile(
+    getTeamPath(team.id),
+    JSON.stringify(team, null, 2),
+    "utf-8",
+  );
+}
+
+/**
+ * Get the best teammate for a task type.
+ */
+export function pickTeammateForTask(
+  team: Team,
+  taskType: string,
+): Teammate | null {
+  // Match by role
+  const roleMatch = team.teammates.find((t) => t.role === taskType);
+  if (roleMatch) return roleMatch;
+
+  // Fallback: least busy teammate
+  const sorted = [...team.teammates].sort(
+    (a, b) => a.stats.tasksCompleted - b.stats.tasksCompleted,
+  );
+  return sorted[0] ?? null;
+}