ashlrcode 1.0.0 → 2.1.0

package/src/agent/tool-executor.ts

@@ -10,6 +10,7 @@ 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";
+import { trackFileModification } from "./verification.ts";
 
 // ---------------------------------------------------------------------------
 // Module-level speculation cache (set from repl startup)
@@ -25,6 +26,81 @@ export function getSpeculationCache(): SpeculationCache | null {
   return _speculationCache;
 }
 
+// ---------------------------------------------------------------------------
+// Tool execution metrics — cumulative timing and success tracking
+// ---------------------------------------------------------------------------
+
+interface ToolMetric {
+  name: string;
+  calls: number;
+  errors: number;
+  totalDurationMs: number;
+  minDurationMs: number;
+  maxDurationMs: number;
+}
+
+const _toolMetrics = new Map<string, ToolMetric>();
+
+/** Record a tool execution for metrics tracking. */
+function recordToolMetric(name: string, durationMs: number, isError: boolean): void {
+  const existing = _toolMetrics.get(name) ?? {
+    name,
+    calls: 0,
+    errors: 0,
+    totalDurationMs: 0,
+    minDurationMs: Infinity,
+    maxDurationMs: 0,
+  };
+
+  existing.calls++;
+  if (isError) existing.errors++;
+  existing.totalDurationMs += durationMs;
+  existing.minDurationMs = Math.min(existing.minDurationMs, durationMs);
+  existing.maxDurationMs = Math.max(existing.maxDurationMs, durationMs);
+
+  _toolMetrics.set(name, existing);
+}
+
+/** Get all tool execution metrics (sorted by total calls descending). */
+export function getToolMetrics(): ToolMetric[] {
+  return Array.from(_toolMetrics.values())
+    .sort((a, b) => b.calls - a.calls);
+}
+
+/** Format tool metrics for display. */
+export function formatToolMetrics(): string {
+  const metrics = getToolMetrics();
+  if (metrics.length === 0) return "No tool calls recorded.";
+
+  const lines: string[] = ["Tool Execution Metrics:"];
+  const totalCalls = metrics.reduce((s, m) => s + m.calls, 0);
+  const totalDuration = metrics.reduce((s, m) => s + m.totalDurationMs, 0);
+
+  lines.push(`  Total: ${totalCalls} calls, ${formatMs(totalDuration)} total`);
+  lines.push("");
+
+  for (const m of metrics.slice(0, 15)) {
+    const avgMs = m.calls > 0 ? m.totalDurationMs / m.calls : 0;
+    const errorRate = m.calls > 0 ? Math.round((m.errors / m.calls) * 100) : 0;
+    lines.push(
+      `  ${m.name.padEnd(16)} ${String(m.calls).padStart(4)} calls · avg ${formatMs(avgMs)} · ${errorRate}% err`
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function formatMs(ms: number): string {
+  if (ms >= 60_000) return `${(ms / 60_000).toFixed(1)}m`;
+  if (ms >= 1_000) return `${(ms / 1_000).toFixed(1)}s`;
+  return `${Math.round(ms)}ms`;
+}
+
+/** Reset metrics (for testing). */
+export function resetToolMetrics(): void {
+  _toolMetrics.clear();
+}
+
 export interface ToolExecutionResult {
   toolCallId: string;
   name: string;
@@ -99,6 +175,7 @@ async function executeSingle(
     onToolEnd?: (name: string, result: string, isError: boolean) => void;
   }
 ): Promise<ToolExecutionResult> {
+  const startTime = performance.now();
   const tool = registry.get(tc.name);
 
   // Check speculation cache for read-only tools (skip the full execute path)
@@ -107,6 +184,7 @@ async function executeSingle(
     if (cached !== null) {
       callbacks?.onToolStart?.(tc.name, tc.input);
       callbacks?.onToolEnd?.(tc.name, cached, false);
+      recordToolMetric(tc.name, performance.now() - startTime, false);
 
       // Track for speculation and trigger pre-fetch for next likely call
       trackAndSpeculate(tc.name, tc.input, cached);
@@ -126,17 +204,19 @@ async function executeSingle(
   const { result, isError } = await registry.execute(tc.name, tc.input, context);
 
   callbacks?.onToolEnd?.(tc.name, result, isError);
+  recordToolMetric(tc.name, performance.now() - startTime, 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) {
+  // Invalidate cache and track modifications when write tools execute
+  if (!tool?.isReadOnly()) {
     const filePath = tc.input.file_path;
     if (typeof filePath === "string") {
-      _speculationCache.invalidateForFile(filePath);
+      _speculationCache?.invalidateForFile(filePath);
+      trackFileModification(filePath);
     }
   }
 

package/src/agent/verification.ts

@@ -0,0 +1,223 @@
+/**
+ * Verification Agent — auto-validates multi-file changes.
+ *
+ * After non-trivial edits (2+ files modified), spawns a read-only sub-agent
+ * that reviews the git diff and modified files for:
+ *   - Syntax errors and obvious bugs
+ *   - Logic consistency with stated intent
+ *   - Missing imports, undefined references
+ *   - Unintended side effects
+ *
+ * Claude Code's internal verification agent "doubles completion rates."
+ */
+
+import { runSubAgent, type SubAgentResult } from "./sub-agent.ts";
+import type { ProviderRouter } from "../providers/router.ts";
+import type { ToolRegistry } from "../tools/registry.ts";
+import type { ToolContext } from "../tools/types.ts";
+
+export interface VerificationConfig {
+  router: ProviderRouter;
+  toolRegistry: ToolRegistry;
+  toolContext: ToolContext;
+  systemPrompt: string;
+  /** Minimum number of modified files to auto-trigger verification. Default: 2 */
+  fileThreshold?: number;
+  /** Max iterations for the verification sub-agent. Default: 10 */
+  maxIterations?: number;
+  /** Callback for verification progress */
+  onOutput?: (text: string) => void;
+}
+
+export interface VerificationResult {
+  passed: boolean;
+  issues: VerificationIssue[];
+  summary: string;
+  filesChecked: string[];
+  agentResult: SubAgentResult;
+}
+
+export interface VerificationIssue {
+  severity: "error" | "warning" | "info";
+  file: string;
+  line?: number;
+  description: string;
+}
+
+/**
+ * Track files modified during a turn for automatic verification triggering.
+ *
+ * Uses a per-session global set. In sub-agent contexts, modifications are
+ * tracked in the agent's AsyncLocalStorage context instead (see async-context.ts),
+ * but this global is kept for the main REPL session.
+ */
+const _modifiedFiles = new Set<string>();
+
+export function trackFileModification(filePath: string): void {
+  _modifiedFiles.add(filePath);
+}
+
+export function getModifiedFiles(): string[] {
+  // TODO: When agent context gains file tracking, prefer ctx-scoped files
+  return Array.from(_modifiedFiles);
+}
+
+export function clearModifiedFiles(): void {
+  _modifiedFiles.clear();
+}
+
+export function shouldAutoVerify(threshold: number = 2): boolean {
+  return _modifiedFiles.size >= threshold;
+}
+
+/**
+ * Build the verification prompt with context about what changed.
+ */
+function buildVerificationPrompt(modifiedFiles: string[], intent?: string): string {
+  const fileList = modifiedFiles.map(f => `  - ${f}`).join("\n");
+
+  return `You are a VERIFICATION AGENT. Your job is to review recent code changes for correctness.
+
+## Modified Files
+${fileList}
+
+${intent ? `## Stated Intent\n${intent}\n` : ""}
+## Your Task
+
+1. Use the Diff tool to see what changed (run \`git diff\` via Bash if Diff is unavailable)
+2. Read each modified file to understand the full context
+3. Check for:
+   - **Syntax errors**: Missing brackets, unclosed strings, invalid TypeScript
+   - **Logic bugs**: Off-by-one errors, null/undefined access, wrong conditions
+   - **Missing imports**: References to symbols not imported
+   - **Type mismatches**: Arguments that don't match function signatures
+   - **Unintended side effects**: Changes that break existing behavior
+   - **Incomplete changes**: TODOs left behind, partial implementations
+
+4. Report your findings in this EXACT format:
+
+VERIFICATION_RESULT:
+STATUS: PASS | FAIL
+ISSUES:
+- [ERROR|WARNING|INFO] file.ts:123 — Description of issue
+- [WARNING] other-file.ts — Description
+SUMMARY: One-line summary of verification outcome
+
+If everything looks correct, report STATUS: PASS with no issues.
+Be thorough but avoid false positives — only flag real problems.`;
+}
+
+/**
+ * Parse the verification agent's output into structured results.
+ */
+function parseVerificationOutput(text: string, files: string[]): Omit<VerificationResult, "agentResult"> {
+  const issues: VerificationIssue[] = [];
+  let passed = true;
+  let summary = "Verification completed";
+
+  // Extract STATUS
+  const statusMatch = text.match(/STATUS:\s*(PASS|FAIL)/i);
+  if (statusMatch) {
+    passed = statusMatch[1]!.toUpperCase() === "PASS";
+  }
+
+  // Extract SUMMARY
+  const summaryMatch = text.match(/SUMMARY:\s*(.+)/i);
+  if (summaryMatch) {
+    summary = summaryMatch[1]!.trim();
+  }
+
+  // Extract individual issues
+  const issuePattern = /\[(\w+)\]\s*([^\s:]+?)(?::(\d+))?\s*[—-]\s*(.+)/g;
+  let match;
+  while ((match = issuePattern.exec(text)) !== null) {
+    const severityRaw = match[1]!.toLowerCase();
+    const severity: VerificationIssue["severity"] =
+      severityRaw === "error" ? "error" :
+      severityRaw === "warning" ? "warning" : "info";
+
+    issues.push({
+      severity,
+      file: match[2]!,
+      line: match[3] ? parseInt(match[3], 10) : undefined,
+      description: match[4]!.trim(),
+    });
+
+    if (severity === "error") passed = false;
+  }
+
+  return { passed, issues, summary, filesChecked: files };
+}
+
+/**
+ * Run a verification sub-agent to check recent changes.
+ */
+export async function runVerification(
+  config: VerificationConfig,
+  options?: { intent?: string; files?: string[] }
+): Promise<VerificationResult> {
+  const files = options?.files ?? getModifiedFiles();
+
+  if (files.length === 0) {
+    return {
+      passed: true,
+      issues: [],
+      summary: "No files to verify",
+      filesChecked: [],
+      agentResult: { name: "verification", text: "", toolCalls: [], messages: [] },
+    };
+  }
+
+  const prompt = buildVerificationPrompt(files, options?.intent);
+
+  config.onOutput?.("  Running verification agent...\n");
+
+  const agentResult = await runSubAgent({
+    name: "verification-agent",
+    prompt,
+    systemPrompt: config.systemPrompt + "\n\nYou are a verification agent. Be thorough but concise. Only use read-only tools.",
+    router: config.router,
+    toolRegistry: config.toolRegistry,
+    toolContext: config.toolContext,
+    readOnly: true,
+    maxIterations: config.maxIterations ?? 10,
+    onText: config.onOutput,
+  });
+
+  const parsed = parseVerificationOutput(agentResult.text, files);
+
+  const errorCount = parsed.issues.filter(i => i.severity === "error").length;
+  const warnCount = parsed.issues.filter(i => i.severity === "warning").length;
+
+  config.onOutput?.(
+    parsed.passed
+      ? `  ✓ Verification passed (${files.length} files checked)\n`
+      : `  ✗ Verification failed: ${errorCount} errors, ${warnCount} warnings\n`
+  );
+
+  return { ...parsed, agentResult };
+}
+
+/**
+ * Format verification results for display.
+ */
+export function formatVerificationReport(result: VerificationResult): string {
+  const lines: string[] = [];
+
+  lines.push(result.passed ? "## ✓ Verification Passed" : "## ✗ Verification Failed");
+  lines.push("");
+  lines.push(`**Files checked:** ${result.filesChecked.length}`);
+  lines.push(`**Summary:** ${result.summary}`);
+
+  if (result.issues.length > 0) {
+    lines.push("");
+    lines.push("### Issues");
+    for (const issue of result.issues) {
+      const icon = issue.severity === "error" ? "🔴" : issue.severity === "warning" ? "🟡" : "🔵";
+      const loc = issue.line ? `${issue.file}:${issue.line}` : issue.file;
+      lines.push(`${icon} **${loc}** — ${issue.description}`);
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/agent/worktree-manager.ts

@@ -4,7 +4,8 @@
 
 import { join } from "path";
 import { homedir } from "os";
-import { mkdir } from "fs/promises";
+import { mkdir, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
 
 export interface WorktreeInfo {
   path: string;
@@ -84,3 +85,51 @@ export async function listWorktrees(): Promise<WorktreeInfo[]> {
   }
   return worktrees;
 }
+
+/**
+ * Clean up orphaned worktrees older than maxAgeMs (default: 24 hours).
+ * Safe to call on startup or periodically.
+ */
+export async function cleanupOrphanedWorktrees(maxAgeMs: number = 24 * 60 * 60 * 1000): Promise<number> {
+  if (!existsSync(WORKTREE_DIR)) return 0;
+
+  let cleaned = 0;
+  const now = Date.now();
+
+  try {
+    const entries = await readdir(WORKTREE_DIR);
+    for (const entry of entries) {
+      const fullPath = join(WORKTREE_DIR, entry);
+      try {
+        const stats = await stat(fullPath);
+        if (stats.isDirectory() && (now - stats.mtimeMs) > maxAgeMs) {
+          await removeWorktree(fullPath);
+          cleaned++;
+        }
+      } catch {
+        // Skip entries we can't stat
+      }
+    }
+  } catch {
+    // WORKTREE_DIR unreadable — skip
+  }
+
+  return cleaned;
+}
+
+/**
+ * Cleanup hook for process exit — remove all worktrees from this session.
+ * Register with process.on("exit") or signal handlers.
+ */
+export async function cleanupAllWorktrees(): Promise<void> {
+  try {
+    const worktrees = await listWorktrees();
+    for (const wt of worktrees) {
+      if (wt.path.startsWith(WORKTREE_DIR)) {
+        await removeWorktree(wt.path);
+      }
+    }
+  } catch {
+    // Best effort
+  }
+}