ashlrcode 1.0.0

package/src/tools/agent.ts

@@ -0,0 +1,133 @@
+/**
+ * AgentTool — spawn sub-agents with isolated message context.
+ *
+ * Allows the model to delegate exploration, research, and analysis
+ * to child agents that run with fresh context and report back.
+ */
+
+import chalk from "chalk";
+import type { Tool, ToolContext } from "./types.ts";
+import { runSubAgent, type SubAgentConfig } from "../agent/sub-agent.ts";
+import type { ProviderRouter } from "../providers/router.ts";
+import type { ToolRegistry } from "../tools/registry.ts";
+
+// These get injected at registration time
+let _router: ProviderRouter | null = null;
+let _registry: ToolRegistry | null = null;
+let _systemPrompt: string = "";
+
+export function initAgentTool(
+  router: ProviderRouter,
+  registry: ToolRegistry,
+  systemPrompt: string
+) {
+  _router = router;
+  _registry = registry;
+  _systemPrompt = systemPrompt;
+}
+
+export const agentTool: Tool = {
+  name: "Agent",
+
+  prompt() {
+    return `Launch a sub-agent to handle a task autonomously. The sub-agent has its own fresh conversation context and access to read-only tools (Read, Glob, Grep, WebFetch).
+
+Use this for:
+- Exploring parts of the codebase in parallel
+- Researching a specific question
+- Analyzing files or patterns
+
+The sub-agent's findings are returned as text. Provide a clear, specific prompt describing what to investigate.`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "Short description of what the agent will do (3-5 words)",
+        },
+        prompt: {
+          type: "string",
+          description:
+            "Detailed task description for the sub-agent. Include file paths, search terms, and specific questions.",
+        },
+        readOnly: {
+          type: "boolean",
+          description: "Only allow read-only tools (default: true)",
+        },
+        mode: {
+          type: "string",
+          enum: ["in_process", "worktree"],
+          description:
+            "Execution mode. 'worktree' creates an isolated git worktree so the sub-agent can make changes without affecting the current working tree.",
+        },
+      },
+      required: ["description", "prompt"],
+    };
+  },
+
+  isReadOnly() {
+    return true; // The agent tool itself is read-only; sub-agent tools are filtered
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    if (!input.prompt || typeof input.prompt !== "string") {
+      return "prompt is required";
+    }
+    if (!input.description || typeof input.description !== "string") {
+      return "description is required";
+    }
+    if (!_router || !_registry) {
+      return "AgentTool not initialized. Call initAgentTool() first.";
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const description = input.description as string;
+    const prompt = input.prompt as string;
+    const readOnly = (input.readOnly as boolean) ?? true;
+    const mode = (input.mode as SubAgentConfig["mode"]) ?? "in_process";
+
+    const modeLabel = mode === "worktree" ? " [worktree]" : "";
+    console.log(chalk.dim(`  ◈ Spawning agent${modeLabel}: ${description}`));
+
+    const result = await runSubAgent({
+      name: description,
+      prompt,
+      systemPrompt: _systemPrompt + "\n\nYou are a sub-agent. Be thorough but concise. Report your findings clearly with file paths and line numbers.",
+      router: _router!,
+      toolRegistry: _registry!,
+      toolContext: context,
+      readOnly,
+      mode,
+      maxIterations: 15,
+      onToolStart: (name) => {
+        console.log(chalk.dim(`    ↳ ${name}`));
+      },
+      onToolEnd: (_name, _result, isError) => {
+        if (isError) console.log(chalk.dim(`    ↳ ${chalk.red("error")}`));
+      },
+    });
+
+    const toolSummary = result.toolCalls.length > 0
+      ? `\n\nTools used: ${result.toolCalls.map((t) => t.name).join(", ")}`
+      : "";
+
+    const worktreeInfo = result.worktree
+      ? `\n\nWorktree branch: \`${result.worktree.branch}\` at ${result.worktree.path}`
+      : "";
+
+    console.log(chalk.dim(`  ◈ Agent "${description}" completed${modeLabel}`));
+
+    return `## Agent: ${description}\n\n${result.text}${toolSummary}${worktreeInfo}`;
+  },
+};

package/src/tools/ask-user.ts

@@ -0,0 +1,229 @@
+/**
+ * AskUserQuestion tool — beautifully formatted interactive questions.
+ *
+ * Supports two input modes:
+ *   1. readline (classic CLI) — used when Ink is not active
+ *   2. pending-question callback (Ink mode) — question is displayed via
+ *      console output; the next user submission in repl.tsx resolves
+ *      the pending promise via `answerPendingQuestion()`.
+ */
+
+import { createInterface } from "readline";
+import { isBypassMode } from "../config/permissions.ts";
+import { theme } from "../ui/theme.ts";
+import type { Tool, ToolContext } from "./types.ts";
+
+export interface QuestionOption {
+  label: string;
+  description: string;
+}
+
+// ---------------------------------------------------------------------------
+// Ink-mode pending-question mechanism
+// ---------------------------------------------------------------------------
+
+/** Resolver for the currently pending question (null when idle). */
+let pendingQuestionResolve: ((answer: string) => void) | null = null;
+
+/** Options for the currently pending question. */
+let pendingOptions: QuestionOption[] = [];
+
+/** Check if there is a pending question awaiting an answer. */
+export function hasPendingQuestion(): boolean {
+  return pendingQuestionResolve !== null;
+}
+
+/** Answer a pending question (called from repl.tsx when the user submits input). */
+export function answerPendingQuestion(answer: string): boolean {
+  if (!pendingQuestionResolve) return false;
+  pendingQuestionResolve(answer);
+  pendingQuestionResolve = null;
+  pendingOptions = [];
+  return true;
+}
+
+/** Return the options for the currently pending question. */
+export function getPendingOptions(): QuestionOption[] {
+  return pendingOptions;
+}
+
+export const askUserTool: Tool = {
+  name: "AskUser",
+
+  prompt() {
+    return `Ask the user a question with structured options. Use this when you need to:
+1. Clarify requirements or direction
+2. Present design choices with tradeoffs
+3. Get user input before proceeding with a task
+
+Each question should have 2-4 options with clear labels and descriptions.
+Questions should be specific and emerge from actual analysis, not generic.
+The user can always type a custom answer beyond the provided options.`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "The question to ask the user. Should be clear and specific.",
+        },
+        options: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              label: {
+                type: "string",
+                description: "Short label for this option (1-5 words)",
+              },
+              description: {
+                type: "string",
+                description: "Explanation of what this option means and its tradeoffs",
+              },
+            },
+            required: ["label", "description"],
+          },
+          description: "2-4 options for the user to choose from",
+        },
+      },
+      required: ["question", "options"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.question || typeof input.question !== "string") {
+      return "question is required";
+    }
+    if (!Array.isArray(input.options) || input.options.length < 2) {
+      return "At least 2 options are required";
+    }
+    return null;
+  },
+
+  async call(input, _context) {
+    const question = input.question as string;
+    const options = input.options as QuestionOption[];
+
+    if (isBypassMode()) {
+      return await askInInkMode(question, options);
+    }
+
+    return await askInCliMode(question, options);
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Ink-mode implementation (bypass / Ink active)
+// ---------------------------------------------------------------------------
+
+async function askInInkMode(
+  question: string,
+  options: QuestionOption[],
+): Promise<string> {
+  const w = process.stdout.columns || 80;
+
+  // Display question — Ink captures console output into its log area
+  console.log("");
+  console.log("─".repeat(w));
+  console.log(`\n  ✦  ${question}\n`);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1} → ${opt.label}`);
+    console.log(`       ${opt.description}`);
+    if (i < options.length - 1) console.log("");
+  });
+  console.log(`\n  ${options.length + 1} → Other (type your own answer)`);
+  console.log("\n" + "─".repeat(w));
+
+  // Wait for user to submit input via the repl
+  pendingOptions = options;
+  const answer = await new Promise<string>((resolve) => {
+    pendingQuestionResolve = resolve;
+  });
+
+  const choiceNum = parseInt(answer.trim(), 10);
+  if (choiceNum >= 1 && choiceNum <= options.length) {
+    const selected = options[choiceNum - 1]!;
+    return `User selected: "${selected.label}" — ${selected.description}`;
+  }
+  return `User's custom answer: "${answer.trim()}"`;
+}
+
+// ---------------------------------------------------------------------------
+// CLI-mode implementation (readline, no Ink)
+// ---------------------------------------------------------------------------
+
+async function askInCliMode(
+  question: string,
+  options: QuestionOption[],
+): Promise<string> {
+  const w = process.stdout.columns || 80;
+
+  console.log("");
+  console.log(theme.border("─".repeat(w)));
+  console.log("");
+
+  console.log(theme.accentBold("  ✦  ") + theme.primary(question));
+  console.log("");
+
+  options.forEach((opt, i) => {
+    const num = theme.accent(`  ${i + 1} `);
+    const dot = theme.accent("→");
+    const label = theme.accentBold(` ${opt.label}`);
+    console.log(`${num}${dot}${label}`);
+    console.log(theme.secondary(`       ${opt.description}`));
+    if (i < options.length - 1) console.log("");
+  });
+
+  console.log("");
+  console.log(theme.muted(`  ${options.length + 1} → Other (type your own answer)`));
+
+  console.log("");
+  console.log(theme.border("─".repeat(w)));
+
+  const answer = await promptUser(theme.accent("  Choice: "));
+
+  const choiceNum = parseInt(answer.trim(), 10);
+
+  if (choiceNum >= 1 && choiceNum <= options.length) {
+    const selected = options[choiceNum - 1]!;
+    console.log(theme.success(`  ✓ ${selected.label}`));
+    console.log("");
+    return `User selected: "${selected.label}" — ${selected.description}`;
+  }
+
+  if (choiceNum === options.length + 1 || isNaN(choiceNum)) {
+    const customAnswer = isNaN(choiceNum)
+      ? answer.trim()
+      : await promptUser(theme.accent("  Your answer: "));
+    console.log(theme.success(`  ✓ ${customAnswer}`));
+    console.log("");
+    return `User's custom answer: "${customAnswer}"`;
+  }
+
+  return `User selected option ${answer.trim()}`;
+}
+
+function promptUser(prompt: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}

package/src/tools/bash.ts

@@ -0,0 +1,146 @@
+/**
+ * BashTool — execute shell commands with timeout and live output streaming.
+ */
+
+import chalk from "chalk";
+import type { Tool, ToolContext } from "./types.ts";
+
+const DEFAULT_TIMEOUT = 120_000; // 2 minutes
+const LIVE_OUTPUT_THRESHOLD = 5_000; // Stream live after 5s
+
+export const bashTool: Tool = {
+  name: "Bash",
+
+  prompt() {
+    return "Execute a bash command and return its output. Use for system commands, git operations, running tests, installing packages, etc. Commands run in the project's working directory.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The bash command to execute",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 120000)",
+        },
+      },
+      required: ["command"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    if (!input.command || typeof input.command !== "string") {
+      return "command is required and must be a string";
+    }
+    return null;
+  },
+
+  checkPermissions(input: Record<string, unknown>): string | null {
+    const cmd = input.command as string;
+    if (!cmd) return null;
+    const dangerous = [
+      /\brm\s+-rf\s+[\/~]/,
+      /\bdd\s+.*of=\/dev/,
+      /\bmkfs\b/,
+    ];
+    for (const pattern of dangerous) {
+      if (pattern.test(cmd)) return `Dangerous command pattern: ${pattern.source}`;
+    }
+    return null;
+  },
+
+  async call(input, context) {
+    const command = input.command as string;
+    const timeout = (input.timeout as number) ?? DEFAULT_TIMEOUT;
+
+    const proc = Bun.spawn(["bash", "-c", command], {
+      cwd: context.cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env },
+    });
+
+    const timeoutId = setTimeout(() => {
+      proc.kill();
+    }, timeout);
+
+    // Start reading stderr concurrently (prevents deadlock if pipe buffer fills)
+    const stderrPromise = new Response(proc.stderr).text();
+
+    // Read stdout in chunks
+    const reader = proc.stdout.getReader();
+
+    try {
+      // Collect output with live streaming for long-running commands
+      let stdout = "";
+      let liveMode = false;
+      const startTime = Date.now();
+      const decoder = new TextDecoder();
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        stdout += chunk;
+
+        // Switch to live output after threshold
+        if (!liveMode && Date.now() - startTime > LIVE_OUTPUT_THRESHOLD) {
+          liveMode = true;
+          process.stderr.write(chalk.dim("    [live output]\n"));
+          // Print buffered content
+          if (stdout.length > chunk.length) {
+            process.stderr.write(chalk.dim(stdout.slice(0, -chunk.length)));
+          }
+        }
+        if (liveMode) {
+          process.stderr.write(chalk.dim(chunk));
+        }
+      }
+
+      const stderr = await stderrPromise;
+      const exitCode = await proc.exited;
+      clearTimeout(timeoutId);
+
+      if (liveMode) {
+        process.stderr.write("\n");
+      }
+
+      let result = "";
+      if (stdout) result += stdout;
+      if (stderr) result += (result ? "\n" : "") + stderr;
+      if (exitCode !== 0) {
+        result += `\nExit code: ${exitCode}`;
+      }
+
+      // Truncate very long output for the model
+      if (result.length > 50_000) {
+        result =
+          result.slice(0, 20_000) +
+          `\n\n[... truncated ${result.length - 40_000} chars ...]\n\n` +
+          result.slice(-20_000);
+      }
+
+      return result || "(no output)";
+    } catch {
+      clearTimeout(timeoutId);
+      // Release stdout reader lock and drain stderr
+      try { reader.releaseLock(); } catch {}
+      try { await stderrPromise; } catch {}
+      return "Command timed out";
+    }
+  },
+};

package/src/tools/config.ts

@@ -0,0 +1,147 @@
+/**
+ * ConfigTool — view and modify settings from within the agent.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import { loadSettings, saveSettings } from "../config/settings.ts";
+
+export const configTool: Tool = {
+  name: "Config",
+
+  prompt() {
+    return "View or modify AshlrCode settings. Operations: 'get' (read a setting), 'set' (write a setting), 'list' (show all settings).";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        operation: {
+          type: "string",
+          enum: ["get", "set", "list"],
+          description: "Operation to perform",
+        },
+        key: {
+          type: "string",
+          description: "Setting key (dot-notation, e.g. 'providers.primary.model')",
+        },
+        value: {
+          type: "string",
+          description: "Value to set (for 'set' operation)",
+        },
+      },
+      required: ["operation"],
+    };
+  },
+
+  isReadOnly() {
+    return false;
+  },
+  isDestructive() {
+    return false;
+  },
+  isConcurrencySafe() {
+    return false;
+  },
+
+  validateInput(input) {
+    const op = input.operation as string;
+    if (!["get", "set", "list"].includes(op)) {
+      return "operation must be 'get', 'set', or 'list'";
+    }
+    if (op === "set" && (!input.key || !input.value)) {
+      return "key and value are required for set operation";
+    }
+    return null;
+  },
+
+  async call(input, _context) {
+    const op = input.operation as string;
+    const settings = await loadSettings();
+
+    switch (op) {
+      case "list": {
+        const sanitized = redactSecrets(JSON.parse(JSON.stringify(settings)));
+        return JSON.stringify(sanitized, null, 2);
+      }
+
+      case "get": {
+        const key = input.key as string;
+        // Block direct access to API keys
+        if (key.toLowerCase().includes("apikey") || key.toLowerCase().includes("api_key")) {
+          return "API keys are redacted for security. View them in ~/.ashlrcode/settings.json directly.";
+        }
+        const value = getNestedValue(settings as unknown as Record<string, unknown>, key);
+        if (value === undefined) return `Setting not found: ${key}`;
+        if (typeof value === "object" && value !== null) {
+          // Redact any nested secrets before returning
+          const sanitized = redactSecrets(JSON.parse(JSON.stringify(value)));
+          return JSON.stringify(sanitized, null, 2);
+        }
+        return String(value);
+      }
+
+      case "set": {
+        const key = input.key as string;
+        // Block setting API keys via the tool (security)
+        if (key.toLowerCase().includes("apikey") || key.toLowerCase().includes("api_key")) {
+          return "Cannot set API keys via Config tool. Set them as environment variables or edit ~/.ashlrcode/settings.json directly.";
+        }
+        const value = input.value as string;
+        setNestedValue(settings as unknown as Record<string, unknown>, key, value);
+        await saveSettings(settings);
+        return `Set ${key} = ${value}`;
+      }
+
+      default:
+        return `Unknown operation: ${op}`;
+    }
+  },
+};
+
+function redactSecrets(obj: Record<string, unknown>): Record<string, unknown> {
+  const result = { ...obj };
+  for (const [key, value] of Object.entries(result)) {
+    if (key.toLowerCase().includes("apikey") || key.toLowerCase().includes("api_key") || key.toLowerCase().includes("token") || key.toLowerCase().includes("secret")) {
+      result[key] = "[redacted]";
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = redactSecrets(value as Record<string, unknown>);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((v) =>
+        typeof v === "object" && v !== null ? redactSecrets(v as Record<string, unknown>) : v
+      );
+    }
+  }
+  return result;
+}
+
+function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+  const keys = path.split(".");
+  let current: unknown = obj;
+  for (const key of keys) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+
+function setNestedValue(obj: Record<string, unknown>, path: string, value: string): void {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i]!;
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  // Try to parse as JSON, fallback to string
+  const lastKey = keys[keys.length - 1]!;
+  try {
+    current[lastKey] = JSON.parse(value);
+  } catch {
+    current[lastKey] = value;
+  }
+}