ashlrcode 1.0.0

package/src/tools/team.ts

@@ -0,0 +1,309 @@
+/**
+ * Team management tools — create, manage, and delegate to persistent teammates.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import type { Teammate } from "../agent/team.ts";
+import {
+  createTeam,
+  addTeammate,
+  removeTeammate,
+  deleteTeam,
+  listTeams,
+  loadTeam,
+  pickTeammateForTask,
+  recordTeammateActivity,
+} from "../agent/team.ts";
+import { runSubAgent } from "../agent/sub-agent.ts";
+import type { ProviderRouter } from "../providers/router.ts";
+import type { ToolRegistry } from "./registry.ts";
+
+// Module-level refs injected at registration time (same pattern as agent.ts)
+let _router: ProviderRouter | null = null;
+let _registry: ToolRegistry | null = null;
+let _baseSystemPrompt: string = "";
+
+export function initTeamTools(
+  router: ProviderRouter,
+  registry: ToolRegistry,
+  systemPrompt: string,
+) {
+  _router = router;
+  _registry = registry;
+  _baseSystemPrompt = systemPrompt;
+}
+
+export const teamCreateTool: Tool = {
+  name: "TeamCreate",
+  prompt() {
+    return "Create a new team or add a teammate. Teams persist across sessions and teammates can be assigned specialized roles.";
+  },
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["create_team", "add_teammate"],
+          description: "What to do",
+        },
+        teamName: {
+          type: "string",
+          description: "Team name (for create_team)",
+        },
+        teamId: {
+          type: "string",
+          description: "Team ID (for add_teammate)",
+        },
+        name: { type: "string", description: "Teammate name" },
+        role: {
+          type: "string",
+          enum: ["code-reviewer", "test-writer", "explorer", "implementer"],
+          description: "Teammate role",
+        },
+      },
+      required: ["action"],
+    };
+  },
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  validateInput(input) {
+    const action = input.action as string;
+    if (action === "create_team" && !input.teamName)
+      return "teamName required";
+    if (
+      action === "add_teammate" &&
+      (!input.teamId || !input.name || !input.role)
+    )
+      return "teamId, name, and role required";
+    return null;
+  },
+  async call(input) {
+    const action = input.action as string;
+    if (action === "create_team") {
+      const team = await createTeam(input.teamName as string);
+      return `Team "${team.name}" created (ID: ${team.id})`;
+    }
+    if (action === "add_teammate") {
+      const mate = await addTeammate(
+        input.teamId as string,
+        input.name as string,
+        input.role as string,
+      );
+      return `Teammate "${mate.name}" (${mate.role}) added (ID: ${mate.id})`;
+    }
+    return "Unknown action";
+  },
+};
+
+export const teamDeleteTool: Tool = {
+  name: "TeamDelete",
+  prompt() {
+    return "Delete a team or remove a teammate.";
+  },
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["delete_team", "remove_teammate"],
+        },
+        teamId: { type: "string" },
+        teammateId: {
+          type: "string",
+          description: "For remove_teammate",
+        },
+      },
+      required: ["action", "teamId"],
+    };
+  },
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  validateInput(input) {
+    if (!input.teamId) return "teamId required";
+    if (input.action === "remove_teammate" && !input.teammateId)
+      return "teammateId required";
+    return null;
+  },
+  async call(input) {
+    if (input.action === "delete_team") {
+      const ok = await deleteTeam(input.teamId as string);
+      return ok ? `Team deleted` : `Team not found`;
+    }
+    if (input.action === "remove_teammate") {
+      const ok = await removeTeammate(
+        input.teamId as string,
+        input.teammateId as string,
+      );
+      return ok ? `Teammate removed` : `Not found`;
+    }
+    return "Unknown action";
+  },
+};
+
+export const teamListTool: Tool = {
+  name: "TeamList",
+  prompt() {
+    return "List all teams and their teammates.";
+  },
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        teamId: {
+          type: "string",
+          description: "Optional: show detail for specific team",
+        },
+      },
+    };
+  },
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  validateInput() {
+    return null;
+  },
+  async call(input) {
+    if (input.teamId) {
+      const team = await loadTeam(input.teamId as string);
+      if (!team) return "Team not found";
+      const mates = team.teammates
+        .map(
+          (t) =>
+            `  ${t.name} (${t.role}) — ${t.stats.tasksCompleted} tasks done${t.lastActiveAt ? `, last active ${new Date(t.lastActiveAt).toLocaleDateString()}` : ""}`,
+        )
+        .join("\n");
+      return `Team: ${team.name}\nTeammates:\n${mates || "  (none)"}`;
+    }
+
+    const teams = await listTeams();
+    if (teams.length === 0) return "No teams. Use TeamCreate to create one.";
+    return teams
+      .map((t) => `${t.name} (${t.id}) — ${t.teammates.length} teammates`)
+      .join("\n");
+  },
+};
+
+export const teamDispatchTool: Tool = {
+  name: "TeamDispatch",
+  prompt() {
+    return "Dispatch a task to a teammate. The teammate runs as a sub-agent with their specialized role and system prompt. Returns the teammate's findings/results.";
+  },
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        teamId: { type: "string", description: "Team ID" },
+        teammateId: {
+          type: "string",
+          description:
+            "Teammate ID (optional — auto-picks best match if omitted)",
+        },
+        task: {
+          type: "string",
+          description: "Task description for the teammate",
+        },
+        taskType: {
+          type: "string",
+          description:
+            "Task type for auto-matching (e.g., 'code-reviewer', 'test-writer')",
+        },
+        mode: {
+          type: "string",
+          enum: ["in_process", "worktree"],
+          description: "Execution mode",
+        },
+      },
+      required: ["teamId", "task"],
+    };
+  },
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+  validateInput(input) {
+    if (!input.teamId) return "teamId required";
+    if (!input.task) return "task required";
+    if (!_router || !_registry)
+      return "Team tools not initialized. Call initTeamTools() first.";
+    return null;
+  },
+  async call(input: Record<string, unknown>, context: ToolContext) {
+    const teamId = input.teamId as string;
+    const team = await loadTeam(teamId);
+    if (!team) return "Team not found";
+
+    let teammate: Teammate | null = null;
+    if (input.teammateId) {
+      teammate =
+        team.teammates.find((t) => t.id === (input.teammateId as string)) ??
+        null;
+    } else {
+      teammate = pickTeammateForTask(
+        team,
+        (input.taskType as string) ?? "",
+      );
+    }
+
+    if (!teammate) return "No suitable teammate found";
+
+    const task = input.task as string;
+    const mode = (input.mode as "in_process" | "worktree") ?? "in_process";
+    const readOnly =
+      teammate.role === "code-reviewer" || teammate.role === "explorer";
+
+    console.log(`  ◈ Dispatching to ${teammate.name} (${teammate.role})`);
+
+    const result = await runSubAgent({
+      name: `${teammate.name}-${teammate.role}`,
+      prompt: task,
+      systemPrompt:
+        _baseSystemPrompt + "\n\n" + teammate.systemPrompt,
+      router: _router!,
+      toolRegistry: _registry!,
+      toolContext: context,
+      readOnly,
+      maxIterations: 15,
+      mode,
+    });
+
+    await recordTeammateActivity(
+      teamId,
+      teammate.id,
+      1,
+      result.toolCalls.length,
+    );
+
+    const worktreeInfo = result.worktree
+      ? `\nWorktree: ${result.worktree.path} (${result.worktree.branch})`
+      : "";
+
+    return `## ${teammate.name} (${teammate.role})\n\n${result.text}${worktreeInfo}`;
+  },
+};

package/src/tools/todo-write.ts

@@ -0,0 +1,93 @@
+/**
+ * TodoWrite — write a structured todo/plan list to a file.
+ * Equivalent to Claude Code's TodoWriteTool.
+ */
+
+import { writeFile, mkdir } from "fs/promises";
+import { dirname, resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+
+export const todoWriteTool: Tool = {
+  name: "TodoWrite",
+
+  prompt() {
+    return "Write a structured todo list or plan to a file. Use this to create implementation checklists, track work items, or document a plan. The file is written in markdown format with checkboxes.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Path to write the todo file (e.g., PLAN.md, TODO.md)",
+        },
+        todos: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              task: { type: "string", description: "Task description" },
+              completed: { type: "boolean", description: "Whether the task is done" },
+              subtasks: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    task: { type: "string" },
+                    completed: { type: "boolean" },
+                  },
+                },
+              },
+            },
+            required: ["task"],
+          },
+          description: "List of todo items",
+        },
+      },
+      required: ["file_path", "todos"],
+    };
+  },
+
+  isReadOnly() { return false; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return false; },
+
+  validateInput(input) {
+    if (!input.file_path) return "file_path is required";
+    if (!Array.isArray(input.todos) || input.todos.length === 0) {
+      return "todos must be a non-empty array";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = resolve(context.cwd, input.file_path as string);
+    const todos = input.todos as Array<{
+      task: string;
+      completed?: boolean;
+      subtasks?: Array<{ task: string; completed?: boolean }>;
+    }>;
+
+    const lines: string[] = ["# Plan\n"];
+
+    for (const todo of todos) {
+      const check = todo.completed ? "x" : " ";
+      lines.push(`- [${check}] ${todo.task}`);
+
+      if (todo.subtasks) {
+        for (const sub of todo.subtasks) {
+          const subCheck = sub.completed ? "x" : " ";
+          lines.push(`  - [${subCheck}] ${sub.task}`);
+        }
+      }
+    }
+
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, lines.join("\n") + "\n", "utf-8");
+
+    const total = todos.length;
+    const completed = todos.filter((t) => t.completed).length;
+    return `Wrote ${total} todos (${completed} completed) to ${filePath}`;
+  },
+};

package/src/tools/tool-search.ts

@@ -0,0 +1,83 @@
+/**
+ * ToolSearch — find tools by keyword.
+ * Useful when 30+ tools are registered (including MCP tools).
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import type { ToolRegistry } from "./registry.ts";
+
+// Injected at registration time
+let _registry: ToolRegistry | null = null;
+
+export function initToolSearch(registry: ToolRegistry): void {
+  _registry = registry;
+}
+
+export const toolSearchTool: Tool = {
+  name: "ToolSearch",
+
+  prompt() {
+    return "Search for available tools by keyword. Returns matching tool names and descriptions. Useful when many tools are registered (including MCP tools).";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Keyword to search for in tool names and descriptions",
+        },
+        maxResults: {
+          type: "number",
+          description: "Maximum results to return (default: 10)",
+        },
+      },
+      required: ["query"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.query || typeof input.query !== "string") {
+      return "query is required";
+    }
+    return null;
+  },
+
+  async call(input, _context) {
+    if (!_registry) return "ToolSearch not initialized";
+
+    const query = (input.query as string).toLowerCase();
+    const max = (input.maxResults as number) ?? 10;
+
+    const allTools = _registry.getAll();
+    const matches = allTools
+      .filter((t) => {
+        const name = t.name.toLowerCase();
+        const desc = t.prompt().toLowerCase();
+        return name.includes(query) || desc.includes(query);
+      })
+      .slice(0, max);
+
+    if (matches.length === 0) {
+      return `No tools matching "${query}". Total tools: ${allTools.length}`;
+    }
+
+    const lines = matches.map((t) => {
+      const readOnly = t.isReadOnly() ? " [read-only]" : "";
+      return `- **${t.name}**${readOnly}: ${t.prompt().slice(0, 100)}`;
+    });
+
+    return `${matches.length} tool(s) matching "${query}":\n\n${lines.join("\n")}`;
+  },
+};

package/src/tools/types.ts

@@ -0,0 +1,52 @@
+/**
+ * Tool interface — every tool implements this contract.
+ * Follows Claude Code's pattern: validate → permissions → execute.
+ */
+
+import type { ToolDefinition } from "../providers/types.ts";
+
+export interface ToolContext {
+  cwd: string;
+  /** Ask user for permission to run a tool */
+  requestPermission: (tool: string, description: string) => Promise<boolean>;
+  /** Current turn number (for file history tracking) */
+  turnNumber?: number;
+}
+
+export interface Tool {
+  /** Tool name used in API calls */
+  name: string;
+
+  /** Human-readable description for the LLM */
+  prompt(): string;
+
+  /** JSON Schema for the tool's input parameters */
+  inputSchema(): Record<string, unknown>;
+
+  /** Whether this tool only reads data (safe in plan mode) */
+  isReadOnly(): boolean;
+
+  /** Whether this tool could cause damage if misused */
+  isDestructive(): boolean;
+
+  /** Whether multiple instances can run concurrently */
+  isConcurrencySafe(): boolean;
+
+  /** Validate input before execution */
+  validateInput(input: Record<string, unknown>): string | null;
+
+  /** Tool-specific permission check. Return null if allowed, or error string if denied. */
+  checkPermissions?(input: Record<string, unknown>, context: ToolContext): string | null;
+
+  /** Execute the tool and return result text */
+  call(input: Record<string, unknown>, context: ToolContext): Promise<string>;
+}
+
+/** Convert a Tool to the provider-facing ToolDefinition */
+export function toolToDefinition(tool: Tool): ToolDefinition {
+  return {
+    name: tool.name,
+    description: tool.prompt(),
+    input_schema: tool.inputSchema(),
+  };
+}