ashlrcode 1.0.0

package/src/tools/memory.ts

@@ -0,0 +1,148 @@
+/**
+ * Memory management tools — save, list, and delete project memories.
+ *
+ * Memories persist across sessions in ~/.ashlrcode/memory/<project-hash>/
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import {
+  loadMemories,
+  saveMemory,
+  deleteMemory,
+  type MemoryEntry,
+} from "../persistence/memory.ts";
+
+export const memorySaveTool: Tool = {
+  name: "MemorySave",
+
+  prompt() {
+    return `Save a memory for this project. Memories persist across sessions and are loaded into context automatically.
+
+Memory types:
+- user: Information about the user (role, preferences, knowledge)
+- feedback: Guidance on how to approach work (corrections, confirmations)
+- project: Ongoing work context (goals, status, decisions)
+- reference: Pointers to external resources (URLs, tools, docs)
+
+Use when the user asks you to "remember" something, or when you learn important context that should persist.`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Short name for the memory",
+        },
+        description: {
+          type: "string",
+          description: "One-line description (used to decide relevance in future)",
+        },
+        type: {
+          type: "string",
+          enum: ["user", "feedback", "project", "reference"],
+          description: "Memory type",
+        },
+        content: {
+          type: "string",
+          description: "The memory content (markdown)",
+        },
+      },
+      required: ["name", "type", "content"],
+    };
+  },
+
+  isReadOnly() { return false; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return false; },
+
+  validateInput(input) {
+    if (!input.name) return "name is required";
+    if (!input.type) return "type is required";
+    if (!input.content) return "content is required";
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = await saveMemory(context.cwd, {
+      name: input.name as string,
+      description: (input.description as string) ?? "",
+      type: input.type as MemoryEntry["type"],
+      content: input.content as string,
+    });
+    return `Memory saved: ${input.name} → ${filePath}`;
+  },
+};
+
+export const memoryListTool: Tool = {
+  name: "MemoryList",
+
+  prompt() {
+    return "List all memories saved for this project. Shows name, type, and description.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      required: [],
+    };
+  },
+
+  isReadOnly() { return true; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return true; },
+
+  validateInput() { return null; },
+
+  async call(_input, context) {
+    const memories = await loadMemories(context.cwd);
+    if (memories.length === 0) {
+      return "No memories saved for this project.";
+    }
+
+    const lines = memories.map((m) =>
+      `- **${m.name}** (${m.type}): ${m.description || m.content.slice(0, 80)}`
+    );
+    return `${memories.length} memories:\n${lines.join("\n")}`;
+  },
+};
+
+export const memoryDeleteTool: Tool = {
+  name: "MemoryDelete",
+
+  prompt() {
+    return "Delete a memory by name.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the memory to delete",
+        },
+      },
+      required: ["name"],
+    };
+  },
+
+  isReadOnly() { return false; },
+  isDestructive() { return true; },
+  isConcurrencySafe() { return false; },
+
+  validateInput(input) {
+    if (!input.name) return "name is required";
+    return null;
+  },
+
+  async call(input, context) {
+    const deleted = await deleteMemory(context.cwd, input.name as string);
+    if (deleted) {
+      return `Memory deleted: ${input.name}`;
+    }
+    return `Memory not found: ${input.name}`;
+  },
+};

package/src/tools/notebook-edit.ts

@@ -0,0 +1,133 @@
+/**
+ * NotebookEdit tool — edit Jupyter notebook cells.
+ */
+
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { resolve } from "path";
+import type { Tool, ToolContext } from "./types.ts";
+import { fileHistory } from "../state/file-history.ts";
+
+interface NotebookCell {
+  cell_type: "code" | "markdown" | "raw";
+  source: string[];
+  metadata?: Record<string, unknown>;
+  outputs?: unknown[];
+  execution_count?: number | null;
+}
+
+interface Notebook {
+  cells: NotebookCell[];
+  metadata: Record<string, unknown>;
+  nbformat: number;
+  nbformat_minor: number;
+}
+
+export const notebookEditTool: Tool = {
+  name: "NotebookEdit",
+
+  prompt() {
+    return `Edit a Jupyter notebook (.ipynb) cell. Operations:
+- replace: Replace cell content at a given index
+- insert: Insert a new cell at a given index
+- delete: Delete a cell at a given index`;
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "Path to the .ipynb file",
+        },
+        operation: {
+          type: "string",
+          enum: ["replace", "insert", "delete"],
+          description: "Operation to perform",
+        },
+        cell_index: {
+          type: "number",
+          description: "Cell index (0-based)",
+        },
+        cell_type: {
+          type: "string",
+          enum: ["code", "markdown"],
+          description: "Cell type (for insert/replace)",
+        },
+        content: {
+          type: "string",
+          description: "New cell content (for insert/replace)",
+        },
+      },
+      required: ["file_path", "operation", "cell_index"],
+    };
+  },
+
+  isReadOnly() { return false; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return false; },
+
+  validateInput(input) {
+    if (!input.file_path) return "file_path is required";
+    if (!input.operation) return "operation is required";
+    if (input.cell_index === undefined) return "cell_index is required";
+    const op = input.operation as string;
+    if (op !== "delete" && !input.content) return "content is required for insert/replace";
+    return null;
+  },
+
+  async call(input, context) {
+    const filePath = resolve(context.cwd, input.file_path as string);
+    if (!existsSync(filePath)) return `File not found: ${filePath}`;
+
+    await fileHistory.snapshot(filePath);
+
+    const raw = await readFile(filePath, "utf-8");
+    const notebook = JSON.parse(raw) as Notebook;
+    const idx = input.cell_index as number;
+    const op = input.operation as string;
+
+    if (idx < 0 || (op !== "insert" && idx >= notebook.cells.length)) {
+      return `Cell index ${idx} out of range (${notebook.cells.length} cells)`;
+    }
+
+    switch (op) {
+      case "replace": {
+        const cellType = (input.cell_type as string) ?? notebook.cells[idx]!.cell_type;
+        const content = input.content as string;
+        notebook.cells[idx] = {
+          cell_type: cellType as NotebookCell["cell_type"],
+          source: content.split("\n").map((line, i, arr) =>
+            i < arr.length - 1 ? line + "\n" : line
+          ),
+          metadata: {},
+          ...(cellType === "code" ? { outputs: [], execution_count: null } : {}),
+        };
+        break;
+      }
+
+      case "insert": {
+        const cellType = (input.cell_type as string) ?? "code";
+        const content = input.content as string;
+        const newCell: NotebookCell = {
+          cell_type: cellType as NotebookCell["cell_type"],
+          source: content.split("\n").map((line, i, arr) =>
+            i < arr.length - 1 ? line + "\n" : line
+          ),
+          metadata: {},
+          ...(cellType === "code" ? { outputs: [], execution_count: null } : {}),
+        };
+        notebook.cells.splice(idx, 0, newCell);
+        break;
+      }
+
+      case "delete":
+        notebook.cells.splice(idx, 1);
+        break;
+    }
+
+    await writeFile(filePath, JSON.stringify(notebook, null, 1) + "\n", "utf-8");
+    return `${op} cell ${idx} in ${filePath} (${notebook.cells.length} cells total)`;
+  },
+};

package/src/tools/peers.ts

@@ -0,0 +1,113 @@
+/**
+ * ListPeers tool — discover and communicate with other running AshlrCode instances.
+ *
+ * Actions:
+ *   list  — show all active peers (pid, cwd, session)
+ *   send  — send a message to a peer by ID
+ *   inbox — read received messages
+ */
+
+import type { Tool } from "./types.ts";
+import { listPeers, sendToPeer, readInbox, getPeerId } from "../agent/ipc.ts";
+
+export const listPeersTool: Tool = {
+  name: "ListPeers",
+
+  prompt() {
+    return (
+      "List other running AshlrCode instances and communicate with them via IPC. " +
+      "Use action 'list' to discover peers, 'send' to message a peer, 'inbox' to read received messages."
+    );
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "send", "inbox"],
+          description: "Action to perform: list peers, send a message, or check inbox",
+        },
+        peerId: {
+          type: "string",
+          description: "Target peer ID (required for 'send')",
+        },
+        message: {
+          type: "string",
+          description: "Message content (required for 'send')",
+        },
+      },
+      required: ["action"],
+    };
+  },
+
+  isReadOnly() {
+    return true;
+  },
+
+  isDestructive() {
+    return false;
+  },
+
+  isConcurrencySafe() {
+    return true;
+  },
+
+  validateInput(input) {
+    const action = input.action as string | undefined;
+    if (!action || !["list", "send", "inbox"].includes(action)) {
+      return "action must be one of: list, send, inbox";
+    }
+    if (action === "send") {
+      if (!input.peerId || typeof input.peerId !== "string") {
+        return "peerId is required for send action";
+      }
+      if (!input.message || typeof input.message !== "string") {
+        return "message is required for send action";
+      }
+    }
+    return null;
+  },
+
+  async call(input) {
+    const action = input.action as string;
+
+    if (action === "list") {
+      const peers = await listPeers();
+      const myId = getPeerId();
+      if (peers.length === 0) {
+        return "No AshlrCode instances running (IPC server may not be started).";
+      }
+      const lines = peers.map((p) => {
+        const self = p.id === myId ? " (self)" : "";
+        return `  ${p.id}${self}  pid=${p.pid}  cwd=${p.cwd}  session=${p.sessionId}  started=${p.startedAt}`;
+      });
+      return `Active peers (${peers.length}):\n${lines.join("\n")}`;
+    }
+
+    if (action === "inbox") {
+      const msgs = readInbox();
+      if (msgs.length === 0) {
+        return "Inbox is empty — no messages received.";
+      }
+      const lines = msgs.map(
+        (m) => `  [${m.timestamp}] from=${m.from} type=${m.type}: ${m.payload}`,
+      );
+      return `${msgs.length} message(s):\n${lines.join("\n")}`;
+    }
+
+    if (action === "send") {
+      const ok = await sendToPeer(
+        input.peerId as string,
+        "message",
+        input.message as string,
+      );
+      return ok
+        ? "Message sent successfully."
+        : "Failed to send — peer not found or unreachable.";
+    }
+
+    return "Unknown action.";
+  },
+};

package/src/tools/powershell.ts

@@ -0,0 +1,83 @@
+/**
+ * PowerShellTool — execute PowerShell commands on Windows.
+ */
+
+import chalk from "chalk";
+import type { Tool, ToolContext } from "./types.ts";
+
+const DEFAULT_TIMEOUT = 120_000;
+
+export const powershellTool: Tool = {
+  name: "PowerShell",
+
+  prompt() {
+    return "Execute a PowerShell command on Windows. Use for system commands, file operations, and Windows-specific tasks.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The PowerShell 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";
+    return null;
+  },
+
+  async call(input, context) {
+    const command = input.command as string;
+    const timeout = (input.timeout as number) ?? DEFAULT_TIMEOUT;
+
+    const shell = process.platform === "win32" ? "powershell.exe" : "pwsh";
+    const proc = Bun.spawn([shell, "-NoProfile", "-NonInteractive", "-Command", command], {
+      cwd: context.cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env },
+    });
+
+    const timeoutId = setTimeout(() => proc.kill(), timeout);
+    const stderrPromise = new Response(proc.stderr).text();
+    const reader = proc.stdout.getReader();
+    const decoder = new TextDecoder();
+
+    try {
+      let stdout = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        stdout += decoder.decode(value, { stream: true });
+      }
+
+      const stderr = await stderrPromise;
+      const exitCode = await proc.exited;
+      clearTimeout(timeoutId);
+
+      let result = "";
+      if (stdout) result += stdout;
+      if (stderr) result += (result ? "\n" : "") + stderr;
+      if (exitCode !== 0) result += `\nExit code: ${exitCode}`;
+
+      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);
+      try { reader.releaseLock(); } catch {}
+      try { await stderrPromise; } catch {}
+      return "Command timed out";
+    }
+  },
+};

package/src/tools/registry.ts

@@ -0,0 +1,114 @@
+/**
+ * Tool registry — manages available tools and dispatches calls.
+ * Integrates with hook system for pre/post tool execution.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+import type { ToolDefinition } from "../providers/types.ts";
+import { toolToDefinition } from "./types.ts";
+import { runPreToolHooks, runPostToolHooks, type HooksConfig } from "../config/hooks.ts";
+import { checkRules } from "../config/permissions.ts";
+
+function formatInputPreview(toolName: string, input: Record<string, unknown>): string {
+  switch (toolName) {
+    case "Bash":
+      return `Run: ${input.command}`;
+    case "Write":
+      return `Write to: ${input.file_path}`;
+    case "Edit":
+      return `Edit: ${input.file_path}`;
+    default:
+      return JSON.stringify(input).slice(0, 100);
+  }
+}
+
+export class ToolRegistry {
+  private tools = new Map<string, Tool>();
+  private hooks: HooksConfig = {};
+
+  register(tool: Tool): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  setHooks(hooks: HooksConfig): void {
+    this.hooks = hooks;
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  getAll(): Tool[] {
+    return Array.from(this.tools.values());
+  }
+
+  getDefinitions(): ToolDefinition[] {
+    return this.getAll().map(toolToDefinition);
+  }
+
+  /** Get only read-only tools (for plan mode) */
+  getReadOnlyDefinitions(): ToolDefinition[] {
+    return this.getAll()
+      .filter((t) => t.isReadOnly())
+      .map(toolToDefinition);
+  }
+
+  async execute(
+    toolName: string,
+    input: Record<string, unknown>,
+    context: ToolContext
+  ): Promise<{ result: string; isError: boolean }> {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      return { result: `Unknown tool: ${toolName}`, isError: true };
+    }
+
+    // Validate input
+    const validationError = tool.validateInput(input);
+    if (validationError) {
+      return { result: `Validation error: ${validationError}`, isError: true };
+    }
+
+    // Check permissions for non-read-only tools (before hooks, so hooks
+    // don't execute shell commands for tools the user would deny)
+    if (!tool.isReadOnly()) {
+      const ruleResult = checkRules(toolName, input);
+      if (ruleResult === "deny") {
+        return { result: "Denied by permission rule", isError: true };
+      }
+      if (ruleResult !== "allow") {
+        const inputPreview = formatInputPreview(toolName, input);
+        const allowed = await context.requestPermission(toolName, inputPreview);
+        if (!allowed) {
+          return { result: "Permission denied by user", isError: true };
+        }
+      }
+    }
+
+    // Tool-specific permission check
+    if (tool.checkPermissions) {
+      const permError = tool.checkPermissions(input, context);
+      if (permError) {
+        return { result: `Permission denied: ${permError}`, isError: true };
+      }
+    }
+
+    // Run pre-tool hooks (after permission check)
+    const hookResult = await runPreToolHooks(this.hooks, toolName, input);
+    if (hookResult.action === "deny") {
+      return { result: hookResult.message ?? "Denied by hook", isError: true };
+    }
+
+    try {
+      const result = await tool.call(input, context);
+
+      // Run post-tool hooks (fire and forget)
+      runPostToolHooks(this.hooks, toolName, input, result).catch(() => {});
+
+      return { result, isError: false };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { result: `Error: ${message}`, isError: true };
+    }
+  }
+}

package/src/tools/send-message.ts

@@ -0,0 +1,75 @@
+/**
+ * SendMessage tool — send messages between agents.
+ *
+ * Enables agent-to-agent communication for team coordination.
+ */
+
+import type { Tool, ToolContext } from "./types.ts";
+
+// Simple in-memory message inbox
+interface Message {
+  from: string;
+  to: string;
+  content: string;
+  timestamp: string;
+}
+
+const inbox: Message[] = [];
+
+export function getMessages(agentName: string): Message[] {
+  return inbox.filter((m) => m.to === agentName);
+}
+
+export function clearMessages(agentName: string): void {
+  const toRemove = inbox.filter((m) => m.to === agentName);
+  for (const msg of toRemove) {
+    const idx = inbox.indexOf(msg);
+    if (idx >= 0) inbox.splice(idx, 1);
+  }
+}
+
+export const sendMessageTool: Tool = {
+  name: "SendMessage",
+
+  prompt() {
+    return "Send a message to another agent. Used for agent-to-agent communication when coordinating work across sub-agents.";
+  },
+
+  inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        to: {
+          type: "string",
+          description: "Name or ID of the recipient agent",
+        },
+        content: {
+          type: "string",
+          description: "Message content",
+        },
+      },
+      required: ["to", "content"],
+    };
+  },
+
+  isReadOnly() { return true; },
+  isDestructive() { return false; },
+  isConcurrencySafe() { return true; },
+
+  validateInput(input) {
+    if (!input.to) return "to is required";
+    if (!input.content) return "content is required";
+    return null;
+  },
+
+  async call(input, _context) {
+    const msg: Message = {
+      from: "main",
+      to: input.to as string,
+      content: input.content as string,
+      timestamp: new Date().toISOString(),
+    };
+    inbox.push(msg);
+    return `Message sent to ${msg.to}`;
+  },
+};