sparkecoder 0.1.3

package/dist/tools/index.js

@@ -0,0 +1,1366 @@
+// src/tools/bash.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/utils/truncate.ts
+var MAX_OUTPUT_CHARS = 1e4;
+function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
+  if (output.length <= maxChars) {
+    return output;
+  }
+  const halfMax = Math.floor(maxChars / 2);
+  const truncatedChars = output.length - maxChars;
+  return output.slice(0, halfMax) + `
+
+... [TRUNCATED: ${truncatedChars.toLocaleString()} characters omitted] ...
+
+` + output.slice(-halfMax);
+}
+
+// src/tools/bash.ts
+var execAsync = promisify(exec);
+var COMMAND_TIMEOUT = 6e4;
+var MAX_OUTPUT_CHARS2 = 1e4;
+var BLOCKED_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "mkfs",
+  "dd if=/dev/zero",
+  ":(){:|:&};:",
+  "chmod -R 777 /"
+];
+function isBlockedCommand(command) {
+  const normalizedCommand = command.toLowerCase().trim();
+  return BLOCKED_COMMANDS.some(
+    (blocked) => normalizedCommand.includes(blocked.toLowerCase())
+  );
+}
+var bashInputSchema = z.object({
+  command: z.string().describe("The bash command to execute. Can be a single command or a pipeline.")
+});
+function createBashTool(options) {
+  return tool({
+    description: `Execute a bash command in the terminal. The command runs in the working directory: ${options.workingDirectory}. 
+Use this for running shell commands, scripts, git operations, package managers (npm, pip, etc.), and other CLI tools.
+Long outputs will be automatically truncated. Commands have a 60 second timeout.
+IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar operations.`,
+    inputSchema: bashInputSchema,
+    execute: async ({ command }) => {
+      if (isBlockedCommand(command)) {
+        return {
+          success: false,
+          error: "This command is blocked for safety reasons.",
+          stdout: "",
+          stderr: "",
+          exitCode: 1
+        };
+      }
+      try {
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: options.workingDirectory,
+          timeout: COMMAND_TIMEOUT,
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB buffer
+          shell: "/bin/bash"
+        });
+        const truncatedStdout = truncateOutput(stdout, MAX_OUTPUT_CHARS2);
+        const truncatedStderr = truncateOutput(stderr, MAX_OUTPUT_CHARS2 / 2);
+        if (options.onOutput) {
+          options.onOutput(truncatedStdout);
+        }
+        return {
+          success: true,
+          stdout: truncatedStdout,
+          stderr: truncatedStderr,
+          exitCode: 0
+        };
+      } catch (error) {
+        const stdout = error.stdout ? truncateOutput(error.stdout, MAX_OUTPUT_CHARS2) : "";
+        const stderr = error.stderr ? truncateOutput(error.stderr, MAX_OUTPUT_CHARS2) : "";
+        if (options.onOutput) {
+          options.onOutput(stderr || error.message);
+        }
+        if (error.killed) {
+          return {
+            success: false,
+            error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
+            stdout,
+            stderr,
+            exitCode: 124
+            // Standard timeout exit code
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          stdout,
+          stderr,
+          exitCode: error.code ?? 1
+        };
+      }
+    }
+  });
+}
+
+// src/tools/read-file.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+import { readFile, stat } from "fs/promises";
+import { resolve, relative, isAbsolute } from "path";
+import { existsSync } from "fs";
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_OUTPUT_CHARS3 = 5e4;
+var readFileInputSchema = z2.object({
+  path: z2.string().describe("The path to the file to read. Can be relative to working directory or absolute."),
+  startLine: z2.number().optional().describe("Optional: Start reading from this line number (1-indexed)"),
+  endLine: z2.number().optional().describe("Optional: Stop reading at this line number (1-indexed, inclusive)")
+});
+function createReadFileTool(options) {
+  return tool2({
+    description: `Read the contents of a file. Provide a path relative to the working directory (${options.workingDirectory}) or an absolute path.
+Large files will be automatically truncated. Binary files are not supported.
+Use this to understand existing code, check file contents, or gather context.`,
+    inputSchema: readFileInputSchema,
+    execute: async ({ path, startLine, endLine }) => {
+      try {
+        const absolutePath = isAbsolute(path) ? path : resolve(options.workingDirectory, path);
+        const relativePath = relative(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional.",
+            content: null
+          };
+        }
+        if (!existsSync(absolutePath)) {
+          return {
+            success: false,
+            error: `File not found: ${path}`,
+            content: null
+          };
+        }
+        const stats = await stat(absolutePath);
+        if (stats.size > MAX_FILE_SIZE) {
+          return {
+            success: false,
+            error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB.`,
+            content: null
+          };
+        }
+        if (stats.isDirectory()) {
+          return {
+            success: false,
+            error: 'Path is a directory, not a file. Use bash with "ls" to list directory contents.',
+            content: null
+          };
+        }
+        let content = await readFile(absolutePath, "utf-8");
+        if (startLine !== void 0 || endLine !== void 0) {
+          const lines = content.split("\n");
+          const start = (startLine ?? 1) - 1;
+          const end = endLine ?? lines.length;
+          if (start < 0 || start >= lines.length) {
+            return {
+              success: false,
+              error: `Start line ${startLine} is out of range. File has ${lines.length} lines.`,
+              content: null
+            };
+          }
+          content = lines.slice(start, end).join("\n");
+          const lineNumbers = lines.slice(start, end).map((line, idx) => `${(start + idx + 1).toString().padStart(4)}: ${line}`).join("\n");
+          content = lineNumbers;
+        }
+        const truncatedContent = truncateOutput(content, MAX_OUTPUT_CHARS3);
+        const wasTruncated = truncatedContent.length < content.length;
+        return {
+          success: true,
+          path: absolutePath,
+          relativePath: relative(options.workingDirectory, absolutePath),
+          content: truncatedContent,
+          lineCount: content.split("\n").length,
+          wasTruncated,
+          sizeBytes: stats.size
+        };
+      } catch (error) {
+        if (error.code === "ERR_INVALID_ARG_VALUE" || error.message.includes("encoding")) {
+          return {
+            success: false,
+            error: "File appears to be binary and cannot be read as text.",
+            content: null
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          content: null
+        };
+      }
+    }
+  });
+}
+
+// src/tools/write-file.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { resolve as resolve2, relative as relative2, isAbsolute as isAbsolute2, dirname } from "path";
+import { existsSync as existsSync2 } from "fs";
+var writeFileInputSchema = z3.object({
+  path: z3.string().describe("The path to the file. Can be relative to working directory or absolute."),
+  mode: z3.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
+  content: z3.string().optional().describe('For "full" mode: The complete content to write to the file'),
+  old_string: z3.string().optional().describe('For "str_replace" mode: The exact string to find and replace'),
+  new_string: z3.string().optional().describe('For "str_replace" mode: The string to replace old_string with')
+});
+function createWriteFileTool(options) {
+  return tool3({
+    description: `Write content to a file. Supports two modes:
+1. "full" - Write the entire file content (creates new file or replaces existing)
+2. "str_replace" - Replace a specific string in an existing file (for precise edits)
+
+For str_replace mode:
+- Provide the exact string to find (old_string) and its replacement (new_string)
+- The old_string must match EXACTLY (including whitespace and indentation)
+- Only the first occurrence is replaced
+- Use this for surgical edits to existing code
+
+For full mode:
+- Provide the complete file content
+- Creates parent directories if they don't exist
+- Use this for new files or complete rewrites
+
+Working directory: ${options.workingDirectory}`,
+    inputSchema: writeFileInputSchema,
+    execute: async ({ path, mode, content, old_string, new_string }) => {
+      try {
+        const absolutePath = isAbsolute2(path) ? path : resolve2(options.workingDirectory, path);
+        const relativePath = relative2(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute2(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional."
+          };
+        }
+        if (mode === "full") {
+          if (content === void 0) {
+            return {
+              success: false,
+              error: 'Content is required for "full" mode'
+            };
+          }
+          const dir = dirname(absolutePath);
+          if (!existsSync2(dir)) {
+            await mkdir(dir, { recursive: true });
+          }
+          const existed = existsSync2(absolutePath);
+          await writeFile(absolutePath, content, "utf-8");
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative2(options.workingDirectory, absolutePath),
+            mode: "full",
+            action: existed ? "replaced" : "created",
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            lineCount: content.split("\n").length
+          };
+        } else if (mode === "str_replace") {
+          if (old_string === void 0 || new_string === void 0) {
+            return {
+              success: false,
+              error: 'Both old_string and new_string are required for "str_replace" mode'
+            };
+          }
+          if (!existsSync2(absolutePath)) {
+            return {
+              success: false,
+              error: `File not found: ${path}. Use "full" mode to create new files.`
+            };
+          }
+          const currentContent = await readFile2(absolutePath, "utf-8");
+          if (!currentContent.includes(old_string)) {
+            const lines = currentContent.split("\n");
+            const preview = lines.slice(0, 20).join("\n");
+            return {
+              success: false,
+              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
+              hint: "Check for differences in indentation, line endings, or invisible characters.",
+              filePreview: lines.length > 20 ? `${preview}
+... (${lines.length - 20} more lines)` : preview
+            };
+          }
+          const occurrences = currentContent.split(old_string).length - 1;
+          if (occurrences > 1) {
+            return {
+              success: false,
+              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
+              hint: "Include surrounding lines or more specific content in old_string."
+            };
+          }
+          const newContent = currentContent.replace(old_string, new_string);
+          await writeFile(absolutePath, newContent, "utf-8");
+          const oldLines = old_string.split("\n").length;
+          const newLines = new_string.split("\n").length;
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative2(options.workingDirectory, absolutePath),
+            mode: "str_replace",
+            linesRemoved: oldLines,
+            linesAdded: newLines,
+            lineDelta: newLines - oldLines
+          };
+        }
+        return {
+          success: false,
+          error: `Invalid mode: ${mode}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// src/tools/todo.ts
+import { tool as tool4 } from "ai";
+import { z as z4 } from "zod";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { eq, desc, and, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+
+// src/db/schema.ts
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  workingDirectory: text("working_directory").notNull(),
+  model: text("model").notNull(),
+  status: text("status", { enum: ["active", "waiting", "completed", "error"] }).notNull().default("active"),
+  config: text("config", { mode: "json" }).$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Store the entire ModelMessage as JSON (role + content)
+  modelMessage: text("model_message", { mode: "json" }).$type().notNull(),
+  // Sequence number within session to maintain exact ordering
+  sequence: integer("sequence").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var toolExecutions = sqliteTable("tool_executions", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  messageId: text("message_id").references(() => messages.id, { onDelete: "cascade" }),
+  toolName: text("tool_name").notNull(),
+  toolCallId: text("tool_call_id").notNull(),
+  input: text("input", { mode: "json" }),
+  output: text("output", { mode: "json" }),
+  status: text("status", { enum: ["pending", "approved", "rejected", "completed", "error"] }).notNull().default("pending"),
+  requiresApproval: integer("requires_approval", { mode: "boolean" }).notNull().default(false),
+  error: text("error"),
+  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  completedAt: integer("completed_at", { mode: "timestamp" })
+});
+var todoItems = sqliteTable("todo_items", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  content: text("content").notNull(),
+  status: text("status", { enum: ["pending", "in_progress", "completed", "cancelled"] }).notNull().default("pending"),
+  order: integer("order").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var loadedSkills = sqliteTable("loaded_skills", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  skillName: text("skill_name").notNull(),
+  loadedAt: integer("loaded_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var terminals = sqliteTable("terminals", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  name: text("name"),
+  // Optional friendly name (e.g., "dev-server")
+  command: text("command").notNull(),
+  // The command that was run
+  cwd: text("cwd").notNull(),
+  // Working directory
+  pid: integer("pid"),
+  // Process ID (null if not running)
+  status: text("status", { enum: ["running", "stopped", "error"] }).notNull().default("running"),
+  exitCode: integer("exit_code"),
+  // Exit code if stopped
+  error: text("error"),
+  // Error message if status is 'error'
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  stoppedAt: integer("stopped_at", { mode: "timestamp" })
+});
+
+// src/db/index.ts
+var db = null;
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return db;
+}
+var todoQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(todoItems).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  createMany(sessionId, items) {
+    const now = /* @__PURE__ */ new Date();
+    const values = items.map((item, index) => ({
+      id: nanoid(),
+      sessionId,
+      content: item.content,
+      order: item.order ?? index,
+      createdAt: now,
+      updatedAt: now
+    }));
+    return getDb().insert(todoItems).values(values).returning().all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
+    return result.changes > 0;
+  },
+  clearSession(sessionId) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var skillQueries = {
+  load(sessionId, skillName) {
+    const id = nanoid();
+    const result = getDb().insert(loadedSkills).values({
+      id,
+      sessionId,
+      skillName,
+      loadedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+  },
+  isLoaded(sessionId, skillName) {
+    const result = getDb().select().from(loadedSkills).where(
+      and(
+        eq(loadedSkills.sessionId, sessionId),
+        eq(loadedSkills.skillName, skillName)
+      )
+    ).get();
+    return !!result;
+  }
+};
+var terminalQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(terminals).values({
+      id,
+      ...data,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(terminals).where(eq(terminals.id, id)).get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(terminals).where(eq(terminals.sessionId, sessionId)).orderBy(desc(terminals.createdAt)).all();
+  },
+  getRunning(sessionId) {
+    return getDb().select().from(terminals).where(
+      and(
+        eq(terminals.sessionId, sessionId),
+        eq(terminals.status, "running")
+      )
+    ).all();
+  },
+  updateStatus(id, status, exitCode, error) {
+    return getDb().update(terminals).set({
+      status,
+      exitCode,
+      error,
+      stoppedAt: status !== "running" ? /* @__PURE__ */ new Date() : void 0
+    }).where(eq(terminals.id, id)).returning().get();
+  },
+  updatePid(id, pid) {
+    return getDb().update(terminals).set({ pid }).where(eq(terminals.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(terminals).where(eq(terminals.id, id)).run();
+    return result.changes > 0;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(terminals).where(eq(terminals.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+
+// src/tools/todo.ts
+var todoInputSchema = z4.object({
+  action: z4.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
+  items: z4.array(
+    z4.object({
+      content: z4.string().describe("Description of the task"),
+      order: z4.number().optional().describe("Optional order/priority (lower = higher priority)")
+    })
+  ).optional().describe('For "add" action: Array of todo items to add'),
+  todoId: z4.string().optional().describe('For "mark" action: The ID of the todo item to update'),
+  status: z4.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item')
+});
+function createTodoTool(options) {
+  return tool4({
+    description: `Manage your task list for the current session. Use this to:
+- Break down complex tasks into smaller steps
+- Track progress on multi-step operations
+- Organize your work systematically
+
+Available actions:
+- "add": Add one or more new todo items to the list
+- "list": View all current todo items and their status
+- "mark": Update the status of a todo item (pending, in_progress, completed, cancelled)
+- "clear": Remove all todo items from the list
+
+Best practices:
+- Add todos before starting complex tasks
+- Mark items as "in_progress" when actively working on them
+- Update status as you complete each step`,
+    inputSchema: todoInputSchema,
+    execute: async ({ action, items, todoId, status }) => {
+      try {
+        switch (action) {
+          case "add": {
+            if (!items || items.length === 0) {
+              return {
+                success: false,
+                error: "No items provided. Include at least one todo item."
+              };
+            }
+            const created = todoQueries.createMany(options.sessionId, items);
+            return {
+              success: true,
+              action: "add",
+              itemsAdded: created.length,
+              items: created.map(formatTodoItem)
+            };
+          }
+          case "list": {
+            const todos = todoQueries.getBySession(options.sessionId);
+            const stats = {
+              total: todos.length,
+              pending: todos.filter((t) => t.status === "pending").length,
+              inProgress: todos.filter((t) => t.status === "in_progress").length,
+              completed: todos.filter((t) => t.status === "completed").length,
+              cancelled: todos.filter((t) => t.status === "cancelled").length
+            };
+            return {
+              success: true,
+              action: "list",
+              stats,
+              items: todos.map(formatTodoItem)
+            };
+          }
+          case "mark": {
+            if (!todoId) {
+              return {
+                success: false,
+                error: 'todoId is required for "mark" action'
+              };
+            }
+            if (!status) {
+              return {
+                success: false,
+                error: 'status is required for "mark" action'
+              };
+            }
+            const updated = todoQueries.updateStatus(todoId, status);
+            if (!updated) {
+              return {
+                success: false,
+                error: `Todo item not found: ${todoId}`
+              };
+            }
+            return {
+              success: true,
+              action: "mark",
+              item: formatTodoItem(updated)
+            };
+          }
+          case "clear": {
+            const count = todoQueries.clearSession(options.sessionId);
+            return {
+              success: true,
+              action: "clear",
+              itemsRemoved: count
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatTodoItem(item) {
+  return {
+    id: item.id,
+    content: item.content,
+    status: item.status,
+    order: item.order,
+    createdAt: item.createdAt.toISOString()
+  };
+}
+
+// src/tools/load-skill.ts
+import { tool as tool5 } from "ai";
+import { z as z6 } from "zod";
+
+// src/skills/index.ts
+import { readFile as readFile3, readdir } from "fs/promises";
+import { resolve as resolve3, basename, extname } from "path";
+import { existsSync as existsSync3 } from "fs";
+
+// src/config/types.ts
+import { z as z5 } from "zod";
+var ToolApprovalConfigSchema = z5.object({
+  bash: z5.boolean().optional().default(true),
+  write_file: z5.boolean().optional().default(false),
+  read_file: z5.boolean().optional().default(false),
+  load_skill: z5.boolean().optional().default(false),
+  todo: z5.boolean().optional().default(false)
+});
+var SkillMetadataSchema = z5.object({
+  name: z5.string(),
+  description: z5.string()
+});
+var SessionConfigSchema = z5.object({
+  toolApprovals: z5.record(z5.string(), z5.boolean()).optional(),
+  approvalWebhook: z5.string().url().optional(),
+  skillsDirectory: z5.string().optional(),
+  maxContextChars: z5.number().optional().default(2e5)
+});
+var SparkcoderConfigSchema = z5.object({
+  // Default model to use (Vercel AI Gateway format)
+  defaultModel: z5.string().default("anthropic/claude-opus-4-5"),
+  // Working directory for file operations
+  workingDirectory: z5.string().optional(),
+  // Tool approval settings
+  toolApprovals: ToolApprovalConfigSchema.optional().default({}),
+  // Approval webhook URL (called when approval is needed)
+  approvalWebhook: z5.string().url().optional(),
+  // Skills configuration
+  skills: z5.object({
+    // Directory containing skill files
+    directory: z5.string().optional().default("./skills"),
+    // Additional skill directories to include
+    additionalDirectories: z5.array(z5.string()).optional().default([])
+  }).optional().default({}),
+  // Context management
+  context: z5.object({
+    // Maximum context size before summarization (in characters)
+    maxChars: z5.number().optional().default(2e5),
+    // Enable automatic summarization
+    autoSummarize: z5.boolean().optional().default(true),
+    // Number of recent messages to keep after summarization
+    keepRecentMessages: z5.number().optional().default(10)
+  }).optional().default({}),
+  // Server configuration
+  server: z5.object({
+    port: z5.number().default(3141),
+    host: z5.string().default("127.0.0.1")
+  }).default({ port: 3141, host: "127.0.0.1" }),
+  // Database path
+  databasePath: z5.string().optional().default("./sparkecoder.db")
+});
+
+// src/skills/index.ts
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  try {
+    const lines = frontmatter.split("\n");
+    const data = {};
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        data[key] = value;
+      }
+    }
+    const metadata = SkillMetadataSchema.parse(data);
+    return { metadata, body: body.trim() };
+  } catch {
+    return null;
+  }
+}
+function getSkillNameFromPath(filePath) {
+  return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function loadSkillsFromDirectory(directory) {
+  if (!existsSync3(directory)) {
+    return [];
+  }
+  const skills = [];
+  const files = await readdir(directory);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = resolve3(directory, file);
+    const content = await readFile3(filePath, "utf-8");
+    const parsed = parseSkillFrontmatter(content);
+    if (parsed) {
+      skills.push({
+        name: parsed.metadata.name,
+        description: parsed.metadata.description,
+        filePath
+      });
+    } else {
+      const name = getSkillNameFromPath(filePath);
+      const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
+      skills.push({
+        name,
+        description: firstParagraph.replace(/^#\s*/, "").trim(),
+        filePath
+      });
+    }
+  }
+  return skills;
+}
+async function loadAllSkills(directories) {
+  const allSkills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const dir of directories) {
+    const skills = await loadSkillsFromDirectory(dir);
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  return allSkills;
+}
+async function loadSkillContent(skillName, directories) {
+  const allSkills = await loadAllSkills(directories);
+  const skill = allSkills.find(
+    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  );
+  if (!skill) {
+    return null;
+  }
+  const content = await readFile3(skill.filePath, "utf-8");
+  const parsed = parseSkillFrontmatter(content);
+  return {
+    ...skill,
+    content: parsed ? parsed.body : content
+  };
+}
+function formatSkillsForContext(skills) {
+  if (skills.length === 0) {
+    return "No skills available.";
+  }
+  const lines = ["Available skills (use load_skill tool to load into context):"];
+  for (const skill of skills) {
+    lines.push(`- ${skill.name}: ${skill.description}`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/load-skill.ts
+var loadSkillInputSchema = z6.object({
+  action: z6.enum(["list", "load"]).describe('Action to perform: "list" to see available skills, "load" to load a skill'),
+  skillName: z6.string().optional().describe('For "load" action: The name of the skill to load')
+});
+function createLoadSkillTool(options) {
+  return tool5({
+    description: `Load a skill document into the conversation context. Skills are specialized knowledge files that provide guidance on specific topics like debugging, code review, architecture patterns, etc.
+
+Available actions:
+- "list": Show all available skills with their descriptions
+- "load": Load a specific skill's full content into context
+
+Use this when you need specialized knowledge or guidance for a particular task.
+Once loaded, a skill's content will be available in the conversation context.`,
+    inputSchema: loadSkillInputSchema,
+    execute: async ({ action, skillName }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const skills = await loadAllSkills(options.skillsDirectories);
+            return {
+              success: true,
+              action: "list",
+              skillCount: skills.length,
+              skills: skills.map((s) => ({
+                name: s.name,
+                description: s.description
+              })),
+              formatted: formatSkillsForContext(skills)
+            };
+          }
+          case "load": {
+            if (!skillName) {
+              return {
+                success: false,
+                error: 'skillName is required for "load" action'
+              };
+            }
+            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+              return {
+                success: false,
+                error: `Skill "${skillName}" is already loaded in this session`
+              };
+            }
+            const skill = await loadSkillContent(skillName, options.skillsDirectories);
+            if (!skill) {
+              const allSkills = await loadAllSkills(options.skillsDirectories);
+              return {
+                success: false,
+                error: `Skill "${skillName}" not found`,
+                availableSkills: allSkills.map((s) => s.name)
+              };
+            }
+            skillQueries.load(options.sessionId, skillName);
+            return {
+              success: true,
+              action: "load",
+              skillName: skill.name,
+              description: skill.description,
+              content: skill.content,
+              contentLength: skill.content.length
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// src/tools/terminal.ts
+import { tool as tool6 } from "ai";
+import { z as z7 } from "zod";
+
+// src/terminal/manager.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var LogBuffer = class {
+  buffer = [];
+  maxSize;
+  totalBytes = 0;
+  maxBytes;
+  constructor(maxBytes = 50 * 1024) {
+    this.maxBytes = maxBytes;
+    this.maxSize = 1e3;
+  }
+  append(data) {
+    const lines = data.split("\n");
+    for (const line of lines) {
+      if (line) {
+        this.buffer.push(line);
+        this.totalBytes += line.length;
+      }
+    }
+    while (this.totalBytes > this.maxBytes && this.buffer.length > 1) {
+      const removed = this.buffer.shift();
+      if (removed) {
+        this.totalBytes -= removed.length;
+      }
+    }
+    while (this.buffer.length > this.maxSize) {
+      const removed = this.buffer.shift();
+      if (removed) {
+        this.totalBytes -= removed.length;
+      }
+    }
+  }
+  getAll() {
+    return this.buffer.join("\n");
+  }
+  getTail(lines) {
+    const start = Math.max(0, this.buffer.length - lines);
+    return this.buffer.slice(start).join("\n");
+  }
+  clear() {
+    this.buffer = [];
+    this.totalBytes = 0;
+  }
+  get lineCount() {
+    return this.buffer.length;
+  }
+};
+var TerminalManager = class _TerminalManager extends EventEmitter {
+  processes = /* @__PURE__ */ new Map();
+  static instance = null;
+  constructor() {
+    super();
+  }
+  static getInstance() {
+    if (!_TerminalManager.instance) {
+      _TerminalManager.instance = new _TerminalManager();
+    }
+    return _TerminalManager.instance;
+  }
+  /**
+   * Spawn a new background process
+   */
+  spawn(options) {
+    const { sessionId, command, cwd, name, env } = options;
+    const parts = this.parseCommand(command);
+    const executable = parts[0];
+    const args = parts.slice(1);
+    const terminal = terminalQueries.create({
+      sessionId,
+      name: name || null,
+      command,
+      cwd: cwd || process.cwd(),
+      status: "running"
+    });
+    const proc = spawn(executable, args, {
+      cwd: cwd || process.cwd(),
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+      detached: false
+    });
+    if (proc.pid) {
+      terminalQueries.updatePid(terminal.id, proc.pid);
+    }
+    const logs = new LogBuffer();
+    proc.stdout?.on("data", (data) => {
+      const text2 = data.toString();
+      logs.append(text2);
+      this.emit("stdout", { terminalId: terminal.id, data: text2 });
+    });
+    proc.stderr?.on("data", (data) => {
+      const text2 = data.toString();
+      logs.append(`[stderr] ${text2}`);
+      this.emit("stderr", { terminalId: terminal.id, data: text2 });
+    });
+    proc.on("exit", (code, signal) => {
+      const exitCode = code ?? (signal ? 128 : 0);
+      terminalQueries.updateStatus(terminal.id, "stopped", exitCode);
+      this.emit("exit", { terminalId: terminal.id, code: exitCode, signal });
+      const managed2 = this.processes.get(terminal.id);
+      if (managed2) {
+        managed2.terminal = { ...managed2.terminal, status: "stopped", exitCode };
+      }
+    });
+    proc.on("error", (err) => {
+      terminalQueries.updateStatus(terminal.id, "error", void 0, err.message);
+      this.emit("error", { terminalId: terminal.id, error: err.message });
+      const managed2 = this.processes.get(terminal.id);
+      if (managed2) {
+        managed2.terminal = { ...managed2.terminal, status: "error", error: err.message };
+      }
+    });
+    const managed = {
+      id: terminal.id,
+      process: proc,
+      logs,
+      terminal: { ...terminal, pid: proc.pid ?? null }
+    };
+    this.processes.set(terminal.id, managed);
+    return this.toTerminalInfo(managed.terminal);
+  }
+  /**
+   * Get logs from a terminal
+   */
+  getLogs(terminalId, tail) {
+    const managed = this.processes.get(terminalId);
+    if (!managed) {
+      return null;
+    }
+    return {
+      logs: tail ? managed.logs.getTail(tail) : managed.logs.getAll(),
+      lineCount: managed.logs.lineCount
+    };
+  }
+  /**
+   * Get terminal status
+   */
+  getStatus(terminalId) {
+    const managed = this.processes.get(terminalId);
+    if (managed) {
+      if (managed.process.exitCode !== null) {
+        managed.terminal = {
+          ...managed.terminal,
+          status: "stopped",
+          exitCode: managed.process.exitCode
+        };
+      }
+      return this.toTerminalInfo(managed.terminal);
+    }
+    const terminal = terminalQueries.getById(terminalId);
+    if (terminal) {
+      return this.toTerminalInfo(terminal);
+    }
+    return null;
+  }
+  /**
+   * Kill a terminal process
+   */
+  kill(terminalId, signal = "SIGTERM") {
+    const managed = this.processes.get(terminalId);
+    if (!managed) {
+      return false;
+    }
+    try {
+      managed.process.kill(signal);
+      return true;
+    } catch (err) {
+      console.error(`Failed to kill terminal ${terminalId}:`, err);
+      return false;
+    }
+  }
+  /**
+   * Write to a terminal's stdin
+   */
+  write(terminalId, input) {
+    const managed = this.processes.get(terminalId);
+    if (!managed || !managed.process.stdin) {
+      return false;
+    }
+    try {
+      managed.process.stdin.write(input);
+      return true;
+    } catch (err) {
+      console.error(`Failed to write to terminal ${terminalId}:`, err);
+      return false;
+    }
+  }
+  /**
+   * List all terminals for a session
+   */
+  list(sessionId) {
+    const terminals2 = terminalQueries.getBySession(sessionId);
+    return terminals2.map((t) => {
+      const managed = this.processes.get(t.id);
+      if (managed) {
+        return this.toTerminalInfo(managed.terminal);
+      }
+      return this.toTerminalInfo(t);
+    });
+  }
+  /**
+   * Get all running terminals for a session
+   */
+  getRunning(sessionId) {
+    return this.list(sessionId).filter((t) => t.status === "running");
+  }
+  /**
+   * Kill all terminals for a session (cleanup)
+   */
+  killAll(sessionId) {
+    let killed = 0;
+    for (const [id, managed] of this.processes) {
+      if (managed.terminal.sessionId === sessionId) {
+        if (this.kill(id)) {
+          killed++;
+        }
+      }
+    }
+    return killed;
+  }
+  /**
+   * Clean up stopped terminals from memory (keep DB records)
+   */
+  cleanup(sessionId) {
+    let cleaned = 0;
+    for (const [id, managed] of this.processes) {
+      if (sessionId && managed.terminal.sessionId !== sessionId) {
+        continue;
+      }
+      if (managed.terminal.status !== "running") {
+        this.processes.delete(id);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * Parse a command string into executable and arguments
+   */
+  parseCommand(command) {
+    const parts = [];
+    let current = "";
+    let inQuote = false;
+    let quoteChar = "";
+    for (const char of command) {
+      if ((char === '"' || char === "'") && !inQuote) {
+        inQuote = true;
+        quoteChar = char;
+      } else if (char === quoteChar && inQuote) {
+        inQuote = false;
+        quoteChar = "";
+      } else if (char === " " && !inQuote) {
+        if (current) {
+          parts.push(current);
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current) {
+      parts.push(current);
+    }
+    return parts.length > 0 ? parts : [command];
+  }
+  toTerminalInfo(terminal) {
+    return {
+      id: terminal.id,
+      name: terminal.name,
+      command: terminal.command,
+      cwd: terminal.cwd,
+      pid: terminal.pid,
+      status: terminal.status,
+      exitCode: terminal.exitCode,
+      error: terminal.error,
+      createdAt: terminal.createdAt,
+      stoppedAt: terminal.stoppedAt
+    };
+  }
+};
+function getTerminalManager() {
+  return TerminalManager.getInstance();
+}
+
+// src/tools/terminal.ts
+var TerminalInputSchema = z7.object({
+  action: z7.enum(["spawn", "logs", "status", "kill", "write", "list"]).describe(
+    "The action to perform: spawn (start process), logs (get output), status (check if running), kill (stop process), write (send stdin), list (show all)"
+  ),
+  // For spawn
+  command: z7.string().optional().describe('For spawn: The command to run (e.g., "npm run dev")'),
+  cwd: z7.string().optional().describe("For spawn: Working directory for the command"),
+  name: z7.string().optional().describe('For spawn: Optional friendly name (e.g., "dev-server")'),
+  // For logs, status, kill, write
+  terminalId: z7.string().optional().describe("For logs/status/kill/write: The terminal ID"),
+  tail: z7.number().optional().describe("For logs: Number of lines to return from the end"),
+  // For kill
+  signal: z7.enum(["SIGTERM", "SIGKILL"]).optional().describe("For kill: Signal to send (default: SIGTERM)"),
+  // For write
+  input: z7.string().optional().describe("For write: The input to send to stdin")
+});
+function createTerminalTool(options) {
+  const { sessionId, workingDirectory } = options;
+  return tool6({
+    description: `Manage background terminal processes. Use this for long-running commands like dev servers, watchers, or any process that shouldn't block.
+
+Actions:
+- spawn: Start a new background process. Requires 'command'. Returns terminal ID.
+- logs: Get output from a terminal. Requires 'terminalId'. Optional 'tail' for recent lines.
+- status: Check if a terminal is still running. Requires 'terminalId'.
+- kill: Stop a terminal process. Requires 'terminalId'. Optional 'signal'.
+- write: Send input to a terminal's stdin. Requires 'terminalId' and 'input'.
+- list: Show all terminals for this session. No other params needed.
+
+Example workflow:
+1. spawn with command="npm run dev", name="dev-server" \u2192 { id: "abc123", status: "running" }
+2. logs with terminalId="abc123", tail=10 \u2192 "Ready on http://localhost:3000"
+3. kill with terminalId="abc123" \u2192 { success: true }`,
+    inputSchema: TerminalInputSchema,
+    execute: async (input) => {
+      const manager = getTerminalManager();
+      switch (input.action) {
+        case "spawn": {
+          if (!input.command) {
+            return { success: false, error: 'spawn requires a "command" parameter' };
+          }
+          const terminal = manager.spawn({
+            sessionId,
+            command: input.command,
+            cwd: input.cwd || workingDirectory,
+            name: input.name
+          });
+          return {
+            success: true,
+            terminal: formatTerminal(terminal),
+            message: `Started "${input.command}" with terminal ID: ${terminal.id}`
+          };
+        }
+        case "logs": {
+          if (!input.terminalId) {
+            return { success: false, error: 'logs requires a "terminalId" parameter' };
+          }
+          const result = manager.getLogs(input.terminalId, input.tail);
+          if (!result) {
+            return {
+              success: false,
+              error: `Terminal not found: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            terminalId: input.terminalId,
+            logs: result.logs,
+            lineCount: result.lineCount
+          };
+        }
+        case "status": {
+          if (!input.terminalId) {
+            return { success: false, error: 'status requires a "terminalId" parameter' };
+          }
+          const status = manager.getStatus(input.terminalId);
+          if (!status) {
+            return {
+              success: false,
+              error: `Terminal not found: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            terminal: formatTerminal(status)
+          };
+        }
+        case "kill": {
+          if (!input.terminalId) {
+            return { success: false, error: 'kill requires a "terminalId" parameter' };
+          }
+          const success = manager.kill(input.terminalId, input.signal);
+          if (!success) {
+            return {
+              success: false,
+              error: `Failed to kill terminal: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            message: `Sent ${input.signal || "SIGTERM"} to terminal ${input.terminalId}`
+          };
+        }
+        case "write": {
+          if (!input.terminalId) {
+            return { success: false, error: 'write requires a "terminalId" parameter' };
+          }
+          if (!input.input) {
+            return { success: false, error: 'write requires an "input" parameter' };
+          }
+          const success = manager.write(input.terminalId, input.input);
+          if (!success) {
+            return {
+              success: false,
+              error: `Failed to write to terminal: ${input.terminalId}`
+            };
+          }
+          return {
+            success: true,
+            message: `Sent input to terminal ${input.terminalId}`
+          };
+        }
+        case "list": {
+          const terminals2 = manager.list(sessionId);
+          return {
+            success: true,
+            terminals: terminals2.map(formatTerminal),
+            count: terminals2.length,
+            running: terminals2.filter((t) => t.status === "running").length
+          };
+        }
+        default:
+          return { success: false, error: `Unknown action: ${input.action}` };
+      }
+    }
+  });
+}
+function formatTerminal(t) {
+  return {
+    id: t.id,
+    name: t.name,
+    command: t.command,
+    cwd: t.cwd,
+    pid: t.pid,
+    status: t.status,
+    exitCode: t.exitCode,
+    error: t.error,
+    createdAt: t.createdAt.toISOString(),
+    stoppedAt: t.stoppedAt?.toISOString() || null
+  };
+}
+
+// src/tools/index.ts
+function createTools(options) {
+  return {
+    bash: createBashTool({
+      workingDirectory: options.workingDirectory,
+      onOutput: options.onBashOutput
+    }),
+    read_file: createReadFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    write_file: createWriteFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    todo: createTodoTool({
+      sessionId: options.sessionId
+    }),
+    load_skill: createLoadSkillTool({
+      sessionId: options.sessionId,
+      skillsDirectories: options.skillsDirectories
+    }),
+    terminal: createTerminalTool({
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory
+    })
+  };
+}
+export {
+  createBashTool,
+  createLoadSkillTool,
+  createReadFileTool,
+  createTerminalTool,
+  createTodoTool,
+  createTools,
+  createWriteFileTool
+};
+//# sourceMappingURL=index.js.map