ashlrcode 1.0.0

package/src/agent/tool-executor.ts

@@ -0,0 +1,162 @@
+/**
+ * Streaming Tool Executor — parallel execution for concurrency-safe tools.
+ *
+ * Partitions tool calls by isConcurrencySafe():
+ * - Safe tools run in parallel via Promise.all()
+ * - Unsafe tools run sequentially
+ */
+
+import type { ToolRegistry } from "../tools/registry.ts";
+import type { ToolContext } from "../tools/types.ts";
+import type { ToolCall } from "../providers/types.ts";
+import type { SpeculationCache } from "./speculation.ts";
+
+// ---------------------------------------------------------------------------
+// Module-level speculation cache (set from repl startup)
+// ---------------------------------------------------------------------------
+
+let _speculationCache: SpeculationCache | null = null;
+
+export function setSpeculationCache(cache: SpeculationCache): void {
+  _speculationCache = cache;
+}
+
+export function getSpeculationCache(): SpeculationCache | null {
+  return _speculationCache;
+}
+
+export interface ToolExecutionResult {
+  toolCallId: string;
+  name: string;
+  input: Record<string, unknown>;
+  result: string;
+  isError: boolean;
+}
+
+/**
+ * Execute tool calls with optimal parallelism.
+ */
+export async function executeToolCalls(
+  toolCalls: ToolCall[],
+  registry: ToolRegistry,
+  context: ToolContext,
+  callbacks?: {
+    onToolStart?: (name: string, input: Record<string, unknown>) => void;
+    onToolEnd?: (name: string, result: string, isError: boolean) => void;
+  }
+): Promise<ToolExecutionResult[]> {
+  if (toolCalls.length === 0) return [];
+  if (toolCalls.length === 1) {
+    return [await executeSingle(toolCalls[0]!, registry, context, callbacks)];
+  }
+
+  // Partition by concurrency safety
+  const safe: ToolCall[] = [];
+  const unsafe: ToolCall[] = [];
+
+  for (const tc of toolCalls) {
+    const tool = registry.get(tc.name);
+    if (tool?.isConcurrencySafe()) {
+      safe.push(tc);
+    } else {
+      unsafe.push(tc);
+    }
+  }
+
+  const results: ToolExecutionResult[] = [];
+
+  // Run safe tools in parallel
+  if (safe.length > 0) {
+    const parallelResults = await Promise.all(
+      safe.map((tc) => executeSingle(tc, registry, context, callbacks))
+    );
+    results.push(...parallelResults);
+  }
+
+  // Run unsafe tools sequentially
+  for (const tc of unsafe) {
+    const result = await executeSingle(tc, registry, context, callbacks);
+    results.push(result);
+  }
+
+  // Restore original tool call ordering
+  const orderMap = new Map(toolCalls.map((tc, i) => [tc.id, i]));
+  results.sort((a, b) => (orderMap.get(a.toolCallId) ?? 0) - (orderMap.get(b.toolCallId) ?? 0));
+
+  return results;
+}
+
+/** Recent tool calls tracked for speculation heuristics. */
+const recentToolCalls: Array<{ name: string; input: Record<string, unknown>; result?: string }> = [];
+const MAX_RECENT = 10;
+
+async function executeSingle(
+  tc: ToolCall,
+  registry: ToolRegistry,
+  context: ToolContext,
+  callbacks?: {
+    onToolStart?: (name: string, input: Record<string, unknown>) => void;
+    onToolEnd?: (name: string, result: string, isError: boolean) => void;
+  }
+): Promise<ToolExecutionResult> {
+  const tool = registry.get(tc.name);
+
+  // Check speculation cache for read-only tools (skip the full execute path)
+  if (tool?.isReadOnly() && _speculationCache) {
+    const cached = _speculationCache.get(tc.name, tc.input);
+    if (cached !== null) {
+      callbacks?.onToolStart?.(tc.name, tc.input);
+      callbacks?.onToolEnd?.(tc.name, cached, false);
+
+      // Track for speculation and trigger pre-fetch for next likely call
+      trackAndSpeculate(tc.name, tc.input, cached);
+
+      return {
+        toolCallId: tc.id,
+        name: tc.name,
+        input: tc.input,
+        result: cached,
+        isError: false,
+      };
+    }
+  }
+
+  callbacks?.onToolStart?.(tc.name, tc.input);
+
+  const { result, isError } = await registry.execute(tc.name, tc.input, context);
+
+  callbacks?.onToolEnd?.(tc.name, result, isError);
+
+  // Cache successful read-only results for future speculation
+  if (tool?.isReadOnly() && _speculationCache && !isError) {
+    _speculationCache.set(tc.name, tc.input, result);
+  }
+
+  // Invalidate cache when write tools execute
+  if (!tool?.isReadOnly() && _speculationCache) {
+    const filePath = tc.input.file_path;
+    if (typeof filePath === "string") {
+      _speculationCache.invalidateForFile(filePath);
+    }
+  }
+
+  // Track and speculatively pre-fetch next likely calls
+  trackAndSpeculate(tc.name, tc.input, isError ? undefined : result);
+
+  return {
+    toolCallId: tc.id,
+    name: tc.name,
+    input: tc.input,
+    result,
+    isError,
+  };
+}
+
+/** Track a tool call and kick off speculative pre-fetching in background. */
+function trackAndSpeculate(name: string, input: Record<string, unknown>, result?: string): void {
+  recentToolCalls.push({ name, input, result });
+  if (recentToolCalls.length > MAX_RECENT) recentToolCalls.shift();
+
+  // Fire-and-forget — speculation failures are harmless
+  _speculationCache?.speculateFromHistory(recentToolCalls).catch(() => {});
+}

package/src/agent/workflow.ts

@@ -0,0 +1,189 @@
+/**
+ * Workflow system — define and run multi-step automation scripts.
+ * Workflows are stored as JSON files in .ashlrcode/workflows/
+ */
+
+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 WorkflowStep {
+  name: string;
+  type: "prompt" | "command" | "tool";
+  value: string; // prompt text, shell command, or tool name
+  input?: Record<string, unknown>; // for tool type
+  continueOnError?: boolean;
+}
+
+export interface Workflow {
+  id: string;
+  name: string;
+  description: string;
+  steps: WorkflowStep[];
+  createdAt: string;
+  lastRunAt?: string;
+  runCount: number;
+}
+
+export interface WorkflowResult {
+  workflow: string;
+  stepsCompleted: number;
+  stepsTotal: number;
+  results: Array<{ step: string; success: boolean; output: string }>;
+  durationMs: number;
+}
+
+function getWorkflowsDir(): string {
+  return join(getConfigDir(), "workflows");
+}
+
+export async function createWorkflow(
+  name: string,
+  description: string,
+  steps: WorkflowStep[],
+): Promise<Workflow> {
+  await mkdir(getWorkflowsDir(), { recursive: true });
+  const workflow: Workflow = {
+    id: `wf-${Date.now()}`,
+    name,
+    description,
+    steps,
+    createdAt: new Date().toISOString(),
+    runCount: 0,
+  };
+  await saveWorkflow(workflow);
+  return workflow;
+}
+
+export async function listWorkflows(): Promise<Workflow[]> {
+  const dir = getWorkflowsDir();
+  if (!existsSync(dir)) return [];
+  const files = await readdir(dir);
+  const workflows: Workflow[] = [];
+  for (const file of files.filter((f) => f.endsWith(".json"))) {
+    try {
+      const raw = await readFile(join(dir, file), "utf-8");
+      workflows.push(JSON.parse(raw) as Workflow);
+    } catch {
+      // skip malformed workflow files
+    }
+  }
+  return workflows.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export async function loadWorkflow(id: string): Promise<Workflow | null> {
+  const path = join(getWorkflowsDir(), `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(await readFile(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function deleteWorkflow(id: string): Promise<boolean> {
+  const path = join(getWorkflowsDir(), `${id}.json`);
+  if (!existsSync(path)) return false;
+  await unlink(path);
+  return true;
+}
+
+export async function markWorkflowRun(id: string): Promise<void> {
+  const wf = await loadWorkflow(id);
+  if (!wf) return;
+  wf.lastRunAt = new Date().toISOString();
+  wf.runCount++;
+  await saveWorkflow(wf);
+}
+
+async function saveWorkflow(wf: Workflow): Promise<void> {
+  await mkdir(getWorkflowsDir(), { recursive: true });
+  await writeFile(
+    join(getWorkflowsDir(), `${wf.id}.json`),
+    JSON.stringify(wf, null, 2),
+    "utf-8",
+  );
+}
+
+/**
+ * Execute a workflow step by step.
+ * The executor callbacks allow the caller to wire up actual prompt/command/tool
+ * execution and observe progress.
+ */
+export async function executeWorkflow(
+  workflow: Workflow,
+  executor: {
+    runPrompt: (prompt: string) => Promise<string>;
+    runCommand: (cmd: string) => Promise<{ output: string; exitCode: number }>;
+    runTool: (
+      name: string,
+      input: Record<string, unknown>,
+    ) => Promise<{ result: string; isError: boolean }>;
+    onStepStart: (step: WorkflowStep, index: number) => void;
+    onStepEnd: (
+      step: WorkflowStep,
+      index: number,
+      success: boolean,
+      output: string,
+    ) => void;
+  },
+): Promise<WorkflowResult> {
+  const startTime = Date.now();
+  const results: WorkflowResult["results"] = [];
+  let completed = 0;
+
+  for (let i = 0; i < workflow.steps.length; i++) {
+    const step = workflow.steps[i]!;
+    executor.onStepStart(step, i);
+
+    try {
+      let output: string;
+      let success: boolean;
+
+      switch (step.type) {
+        case "prompt":
+          output = await executor.runPrompt(step.value);
+          success = true;
+          break;
+        case "command": {
+          const cmdResult = await executor.runCommand(step.value);
+          output = cmdResult.output;
+          success = cmdResult.exitCode === 0;
+          break;
+        }
+        case "tool": {
+          const toolResult = await executor.runTool(
+            step.value,
+            step.input ?? {},
+          );
+          output = toolResult.result;
+          success = !toolResult.isError;
+          break;
+        }
+        default:
+          output = `Unknown step type: ${(step as WorkflowStep).type}`;
+          success = false;
+      }
+
+      results.push({ step: step.name, success, output: output.slice(0, 500) });
+      executor.onStepEnd(step, i, success, output);
+      completed++;
+
+      if (!success && !step.continueOnError) break;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      results.push({ step: step.name, success: false, output: msg });
+      executor.onStepEnd(step, i, false, msg);
+      if (!step.continueOnError) break;
+    }
+  }
+
+  return {
+    workflow: workflow.name,
+    stepsCompleted: completed,
+    stepsTotal: workflow.steps.length,
+    results,
+    durationMs: Date.now() - startTime,
+  };
+}

package/src/agent/worktree-manager.ts

@@ -0,0 +1,86 @@
+/**
+ * Worktree Manager — manages isolated git worktrees for sub-agents.
+ */
+
+import { join } from "path";
+import { homedir } from "os";
+import { mkdir } from "fs/promises";
+
+export interface WorktreeInfo {
+  path: string;
+  branch: string;
+  parentBranch: string;
+}
+
+const WORKTREE_DIR = join(homedir(), ".ashlrcode", "worktrees");
+
+export async function createWorktree(name: string): Promise<WorktreeInfo> {
+  await mkdir(WORKTREE_DIR, { recursive: true });
+
+  const safeName = name.replace(/[^a-zA-Z0-9-_]/g, "-").slice(0, 50);
+  const timestamp = Date.now();
+  const branch = `agent/${safeName}-${timestamp}`;
+  const wtPath = join(WORKTREE_DIR, `${safeName}-${timestamp}`);
+
+  // Get current branch — read streams before awaiting exit to avoid deadlock
+  const headProc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const headStdoutPromise = new Response(headProc.stdout).text();
+  const headStderrPromise = new Response(headProc.stderr).text();
+  const headExit = await headProc.exited;
+  const parentBranch = (await headStdoutPromise).trim();
+  if (headExit !== 0 || !parentBranch) {
+    const headStderr = await headStderrPromise;
+    throw new Error(`Not inside a git repository: ${headStderr}`);
+  }
+
+  // Create worktree with new branch — same pattern: read streams before exit
+  const proc = Bun.spawn(["git", "worktree", "add", "-b", branch, wtPath], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const procStdoutPromise = new Response(proc.stdout).text();
+  const procStderrPromise = new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await procStderrPromise;
+    throw new Error(`Failed to create worktree: ${stderr}`);
+  }
+
+  return { path: wtPath, branch, parentBranch };
+}
+
+export async function removeWorktree(path: string): Promise<void> {
+  const proc = Bun.spawn(
+    ["git", "worktree", "remove", path, "--force"],
+    { stdout: "pipe", stderr: "pipe" },
+  );
+  await proc.exited;
+}
+
+export async function listWorktrees(): Promise<WorktreeInfo[]> {
+  const proc = Bun.spawn(["git", "worktree", "list", "--porcelain"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const output = (await new Response(proc.stdout).text()).trim();
+  await proc.exited;
+
+  const worktrees: WorktreeInfo[] = [];
+  const blocks = output.split("\n\n");
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    const pathLine = lines.find((l) => l.startsWith("worktree "));
+    const branchLine = lines.find((l) => l.startsWith("branch "));
+    if (pathLine && branchLine) {
+      worktrees.push({
+        path: pathLine.replace("worktree ", ""),
+        branch: branchLine.replace("branch refs/heads/", ""),
+        parentBranch: "main",
+      });
+    }
+  }
+  return worktrees;
+}

package/src/autopilot/queue.ts

@@ -0,0 +1,186 @@
+/**
+ * Work queue — stores and manages discovered work items.
+ * Persisted to ~/.ashlrcode/autopilot/<project-hash>.json
+ */
+
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { createHash } from "crypto";
+import { getConfigDir } from "../config/settings.ts";
+import type { WorkItem, WorkItemStatus } from "./types.ts";
+
+function getQueueDir(): string {
+  return join(getConfigDir(), "autopilot");
+}
+
+function getQueuePath(cwd: string): string {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+  return join(getQueueDir(), `${hash}.json`);
+}
+
+export class WorkQueue {
+  private items: WorkItem[] = [];
+  private path: string;
+
+  constructor(cwd: string) {
+    this.path = getQueuePath(cwd);
+  }
+
+  async load(): Promise<void> {
+    if (!existsSync(this.path)) return;
+    try {
+      const raw = await readFile(this.path, "utf-8");
+      this.items = JSON.parse(raw) as WorkItem[];
+    } catch {
+      this.items = [];
+    }
+  }
+
+  async save(): Promise<void> {
+    await mkdir(getQueueDir(), { recursive: true });
+    await writeFile(this.path, JSON.stringify(this.items, null, 2), "utf-8");
+  }
+
+  /**
+   * Add new items, deduplicating by file + line + type.
+   */
+  addItems(newItems: WorkItem[]): number {
+    let added = 0;
+    for (const item of newItems) {
+      const exists = this.items.some(
+        (i) => i.file === item.file && i.line === item.line && i.type === item.type && i.status !== "completed" && i.status !== "rejected"
+      );
+      if (!exists) {
+        this.items.push(item);
+        added++;
+      }
+    }
+    return added;
+  }
+
+  /**
+   * Get items by status, sorted by priority.
+   */
+  getByStatus(status: WorkItemStatus): WorkItem[] {
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    return this.items
+      .filter((i) => i.status === status)
+      .sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  }
+
+  /**
+   * Get all pending items (discovered + approved).
+   */
+  getPending(): WorkItem[] {
+    return [...this.getByStatus("discovered"), ...this.getByStatus("approved")];
+  }
+
+  /**
+   * Approve an item for execution.
+   */
+  approve(id: string): boolean {
+    const item = this.items.find((i) => i.id === id);
+    if (item && item.status === "discovered") {
+      item.status = "approved";
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Approve all discovered items.
+   */
+  approveAll(): number {
+    let count = 0;
+    for (const item of this.items) {
+      if (item.status === "discovered") {
+        item.status = "approved";
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Reject an item.
+   */
+  reject(id: string): boolean {
+    const item = this.items.find((i) => i.id === id);
+    if (item && item.status === "discovered") {
+      item.status = "rejected";
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Mark item as in progress.
+   */
+  startItem(id: string): WorkItem | null {
+    const item = this.items.find((i) => i.id === id);
+    if (item && item.status === "approved") {
+      item.status = "in_progress";
+      return item;
+    }
+    return null;
+  }
+
+  /**
+   * Mark item as completed.
+   */
+  completeItem(id: string): void {
+    const item = this.items.find((i) => i.id === id);
+    if (item) {
+      item.status = "completed";
+      item.completedAt = new Date().toISOString();
+    }
+  }
+
+  /**
+   * Mark item as failed.
+   */
+  failItem(id: string, error: string): void {
+    const item = this.items.find((i) => i.id === id);
+    if (item) {
+      item.status = "failed";
+      item.error = error;
+    }
+  }
+
+  /**
+   * Get summary stats.
+   */
+  getStats(): Record<string, number> {
+    const stats: Record<string, number> = {};
+    for (const item of this.items) {
+      stats[item.status] = (stats[item.status] ?? 0) + 1;
+    }
+    return stats;
+  }
+
+  /**
+   * Get the next approved item to work on.
+   */
+  getNextApproved(): WorkItem | null {
+    return this.getByStatus("approved")[0] ?? null;
+  }
+
+  /**
+   * Total items.
+   */
+  get length(): number {
+    return this.items.length;
+  }
+
+  /**
+   * Clean old completed/rejected items (keep last 100).
+   */
+  cleanup(): void {
+    const active = this.items.filter((i) => !["completed", "rejected", "failed"].includes(i.status));
+    const archived = this.items
+      .filter((i) => ["completed", "rejected", "failed"].includes(i.status))
+      .slice(-100);
+    this.items = [...active, ...archived];
+  }
+}