@averagejoeslab/puppuccino-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2026 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BUILTIN_TOOLS: () => BUILTIN_TOOLS,
+  BashTool: () => BashTool,
+  CONFIG_PATHS: () => CONFIG_PATHS,
+  ConfigSchema: () => ConfigSchema,
+  DEFAULT_SYSTEM_PROMPT: () => DEFAULT_SYSTEM_PROMPT,
+  EditTool: () => EditTool,
+  GlobTool: () => GlobTool,
+  GrepTool: () => GrepTool,
+  HookSchema: () => HookSchema,
+  HooksRunner: () => HooksRunner,
+  ListTool: () => ListTool,
+  MCPClient: () => MCPClient,
+  MCPConnection: () => MCPConnection,
+  MCPServerSchema: () => MCPServerSchema,
+  Memory: () => Memory,
+  PermissionChecker: () => PermissionChecker,
+  PermissionsSchema: () => PermissionsSchema,
+  Provider: () => Provider,
+  ReadTool: () => ReadTool,
+  SessionManager: () => SessionManager,
+  SkillsLoader: () => SkillsLoader,
+  ToolRegistry: () => ToolRegistry,
+  VERSION: () => VERSION,
+  WriteTool: () => WriteTool,
+  appendMessage: () => appendMessage,
+  createAgentState: () => createAgentState,
+  createHooksRunner: () => createHooksRunner,
+  createMCPClient: () => createMCPClient,
+  createMemory: () => createMemory,
+  createPermissionChecker: () => createPermissionChecker,
+  createProvider: () => createProvider,
+  createProviderInstance: () => createProviderInstance,
+  createSession: () => createSession,
+  createSessionManager: () => createSessionManager,
+  createSkillsLoader: () => createSkillsLoader,
+  createToolRegistry: () => createToolRegistry,
+  deleteSession: () => deleteSession,
+  forkSession: () => forkSession,
+  formatProjectContext: () => formatProjectContext,
+  getDataDir: () => getDataDir,
+  getRecentSession: () => getRecentSession,
+  getSessionsDir: () => getSessionsDir,
+  getUserConfigPath: () => getUserConfigPath,
+  listSessions: () => listSessions,
+  loadConfig: () => loadConfig,
+  loadProjectContext: () => loadProjectContext,
+  loadSession: () => loadSession,
+  runAgent: () => runAgent,
+  runAgentLoop: () => runAgentLoop,
+  saveConfig: () => saveConfig,
+  saveSession: () => saveSession
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/index.ts
+var import_zod = require("zod");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var MCPServerSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  transport: import_zod.z.enum(["stdio", "http", "sse"]),
+  command: import_zod.z.string().optional(),
+  args: import_zod.z.array(import_zod.z.string()).optional(),
+  url: import_zod.z.string().optional(),
+  env: import_zod.z.record(import_zod.z.string()).optional(),
+  enabled: import_zod.z.boolean().default(true)
+});
+var HookSchema = import_zod.z.object({
+  event: import_zod.z.enum([
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PostToolUse",
+    "Stop",
+    "PreCompact",
+    "SessionEnd"
+  ]),
+  matcher: import_zod.z.string().optional(),
+  type: import_zod.z.enum(["command", "prompt", "agent"]),
+  command: import_zod.z.string().optional(),
+  prompt: import_zod.z.string().optional(),
+  agent: import_zod.z.string().optional()
+});
+var PermissionsSchema = import_zod.z.object({
+  allowedTools: import_zod.z.array(import_zod.z.string()).optional(),
+  disallowedTools: import_zod.z.array(import_zod.z.string()).optional(),
+  autoApprove: import_zod.z.array(import_zod.z.string()).optional(),
+  yolo: import_zod.z.boolean().default(false)
+});
+var ConfigSchema = import_zod.z.object({
+  // Provider settings
+  provider: import_zod.z.enum(["anthropic", "openai", "groq", "local"]).default("anthropic"),
+  model: import_zod.z.string().default("claude-sonnet-4-20250514"),
+  apiKey: import_zod.z.string().optional(),
+  baseUrl: import_zod.z.string().optional(),
+  // MCP servers
+  mcpServers: import_zod.z.record(MCPServerSchema).optional(),
+  // Permissions
+  permissions: PermissionsSchema.optional(),
+  // Hooks
+  hooks: import_zod.z.record(import_zod.z.array(HookSchema)).optional(),
+  // Skills
+  skills: import_zod.z.object({
+    enabled: import_zod.z.array(import_zod.z.string()).optional(),
+    disabled: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  // Session settings
+  session: import_zod.z.object({
+    persistHistory: import_zod.z.boolean().default(true),
+    maxHistoryDays: import_zod.z.number().default(30)
+  }).optional(),
+  // UI settings
+  theme: import_zod.z.enum(["dark", "light", "kaldi"]).default("kaldi"),
+  // Agent settings
+  agent: import_zod.z.object({
+    maxTokens: import_zod.z.number().default(8192),
+    maxTurns: import_zod.z.number().default(100),
+    systemPrompt: import_zod.z.string().optional()
+  }).optional()
+});
+var CONFIG_PATHS = {
+  // Project-level (highest priority)
+  project: [".puppuccino.json", "puppuccino.json", ".puppuccino/config.json"],
+  // User-level
+  user: [
+    (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "puppuccino", "config.json"),
+    (0, import_node_path.join)((0, import_node_os.homedir)(), ".puppuccino", "config.json")
+  ]
+};
+function getDataDir() {
+  const platform = process.platform;
+  if (process.env.PUPPUCCINO_DATA_DIR) {
+    return process.env.PUPPUCCINO_DATA_DIR;
+  }
+  switch (platform) {
+    case "darwin":
+      return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", "puppuccino");
+    case "win32":
+      return (0, import_node_path.join)(process.env.LOCALAPPDATA || (0, import_node_os.homedir)(), "puppuccino");
+    default:
+      return (0, import_node_path.join)((0, import_node_os.homedir)(), ".local", "share", "puppuccino");
+  }
+}
+function getSessionsDir() {
+  return (0, import_node_path.join)(getDataDir(), "sessions");
+}
+function loadConfigFile(path) {
+  if (!(0, import_node_fs.existsSync)(path)) return null;
+  try {
+    const content = (0, import_node_fs.readFileSync)(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function loadConfig(projectDir) {
+  const configs = [];
+  for (const path of CONFIG_PATHS.user) {
+    const config = loadConfigFile(path);
+    if (config) {
+      configs.push(config);
+      break;
+    }
+  }
+  if (projectDir) {
+    for (const filename of CONFIG_PATHS.project) {
+      const path = (0, import_node_path.join)(projectDir, filename);
+      const config = loadConfigFile(path);
+      if (config) {
+        configs.push(config);
+        break;
+      }
+    }
+  }
+  const envConfig = {};
+  if (process.env.ANTHROPIC_API_KEY) {
+    envConfig.provider = "anthropic";
+    envConfig.apiKey = process.env.ANTHROPIC_API_KEY;
+  } else if (process.env.OPENAI_API_KEY) {
+    envConfig.provider = "openai";
+    envConfig.apiKey = process.env.OPENAI_API_KEY;
+  }
+  if (process.env.PUPPUCCINO_MODEL) {
+    envConfig.model = process.env.PUPPUCCINO_MODEL;
+  }
+  configs.push(envConfig);
+  const merged = configs.reduce((acc, cfg) => ({ ...acc, ...cfg }), {});
+  return ConfigSchema.parse(merged);
+}
+function saveConfig(config, path) {
+  const dir = (0, import_node_path.dirname)(path);
+  if (!(0, import_node_fs.existsSync)(dir)) {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_node_fs.writeFileSync)(path, JSON.stringify(config, null, 2));
+}
+function getUserConfigPath() {
+  return CONFIG_PATHS.user[0];
+}
+
+// src/providers/index.ts
+var import_anthropic = require("@ai-sdk/anthropic");
+var import_openai = require("@ai-sdk/openai");
+var import_ai = require("ai");
+function createProvider(config) {
+  const { provider, apiKey, baseUrl } = config;
+  switch (provider) {
+    case "anthropic":
+      return (0, import_anthropic.createAnthropic)({
+        apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
+        baseURL: baseUrl
+      });
+    case "openai":
+      return (0, import_openai.createOpenAI)({
+        apiKey: apiKey || process.env.OPENAI_API_KEY,
+        baseURL: baseUrl
+      });
+    case "groq":
+      return (0, import_openai.createOpenAI)({
+        apiKey: apiKey || process.env.GROQ_API_KEY,
+        baseURL: baseUrl || "https://api.groq.com/openai/v1"
+      });
+    case "local":
+      return (0, import_openai.createOpenAI)({
+        apiKey: apiKey || "local",
+        baseURL: baseUrl || "http://localhost:11434/v1"
+      });
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}
+function convertTools(tools) {
+  const result = {};
+  for (const t of tools) {
+    result[t.name] = (0, import_ai.tool)({
+      description: t.description,
+      parameters: t.parameters
+    });
+  }
+  return result;
+}
+function convertMessages(messages) {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string") {
+      return {
+        role: msg.role,
+        content: msg.content
+      };
+    }
+    const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text || "").join("");
+    return {
+      role: msg.role,
+      content: textParts
+    };
+  });
+}
+var Provider = class {
+  config;
+  sdk;
+  constructor(config) {
+    this.config = config;
+    this.sdk = createProvider(config);
+  }
+  /**
+   * Send a chat request and get a response
+   */
+  async chat(options) {
+    const {
+      model,
+      messages,
+      tools = [],
+      systemPrompt,
+      maxTokens = 8192,
+      temperature = 0.7
+    } = options;
+    const result = await (0, import_ai.generateText)({
+      model: this.sdk(model),
+      messages: convertMessages(messages),
+      system: systemPrompt,
+      tools: tools.length > 0 ? convertTools(tools) : void 0,
+      maxTokens,
+      temperature
+    });
+    const toolCalls = result.toolCalls?.map((tc) => ({
+      id: tc.toolCallId,
+      name: tc.toolName,
+      input: tc.args
+    })) || [];
+    return {
+      text: result.text,
+      toolCalls,
+      finishReason: result.finishReason,
+      usage: result.usage ? {
+        promptTokens: result.usage.promptTokens,
+        completionTokens: result.usage.completionTokens
+      } : void 0
+    };
+  }
+  /**
+   * Stream a chat response
+   */
+  async *chatStream(options) {
+    const {
+      model,
+      messages,
+      tools = [],
+      systemPrompt,
+      maxTokens = 8192,
+      temperature = 0.7
+    } = options;
+    const result = await (0, import_ai.streamText)({
+      model: this.sdk(model),
+      messages: convertMessages(messages),
+      system: systemPrompt,
+      tools: tools.length > 0 ? convertTools(tools) : void 0,
+      maxTokens,
+      temperature
+    });
+    for await (const chunk of result.textStream) {
+      yield { type: "text", text: chunk };
+    }
+    yield { type: "finish", finishReason: await result.finishReason };
+  }
+  /**
+   * Get current provider type
+   */
+  get providerType() {
+    return this.config.provider;
+  }
+  /**
+   * Get current model
+   */
+  get model() {
+    return this.config.model;
+  }
+};
+function createProviderInstance(config) {
+  return new Provider(config);
+}
+
+// src/tools/index.ts
+var import_zod2 = require("zod");
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+var import_node_child_process = require("child_process");
+
+// src/tools/glob.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+function globToRegex(pattern) {
+  let regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`);
+}
+function shouldIgnore(name) {
+  const ignored = [
+    "node_modules",
+    ".git",
+    ".svn",
+    ".hg",
+    ".DS_Store",
+    "dist",
+    "build",
+    "coverage",
+    ".turbo",
+    ".next",
+    ".nuxt"
+  ];
+  return ignored.includes(name);
+}
+function* walkDir(dir, base) {
+  try {
+    const entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const name = entry.name;
+      if (entry.isDirectory() && shouldIgnore(name)) {
+        continue;
+      }
+      const fullPath = (0, import_node_path2.join)(dir, name);
+      const relativePath = (0, import_node_path2.relative)(base, fullPath);
+      if (entry.isDirectory()) {
+        yield* walkDir(fullPath, base);
+      } else {
+        yield relativePath;
+      }
+    }
+  } catch {
+  }
+}
+async function glob(pattern, basePath = ".") {
+  const absBase = (0, import_node_path2.resolve)(basePath);
+  const regex = globToRegex(pattern);
+  const results = [];
+  for (const file of walkDir(absBase, absBase)) {
+    const normalized = file.replace(/\\/g, "/");
+    if (regex.test(normalized)) {
+      results.push(normalized);
+    }
+  }
+  return results.sort();
+}
+
+// src/tools/index.ts
+var ReadTool = {
+  name: "read",
+  description: "Read the contents of a file. Returns the file contents with line numbers.",
+  parameters: import_zod2.z.object({
+    path: import_zod2.z.string().describe("The file path to read"),
+    offset: import_zod2.z.number().optional().describe("Line number to start reading from (1-based)"),
+    limit: import_zod2.z.number().optional().describe("Maximum number of lines to read")
+  }),
+  async execute(input) {
+    const { path, offset = 1, limit } = input;
+    if (!(0, import_node_fs3.existsSync)(path)) {
+      return `Error: File not found: ${path}`;
+    }
+    try {
+      const content = (0, import_node_fs3.readFileSync)(path, "utf-8");
+      const lines = content.split("\n");
+      const startIdx = Math.max(0, offset - 1);
+      const endIdx = limit ? startIdx + limit : lines.length;
+      const selectedLines = lines.slice(startIdx, endIdx);
+      const formatted = selectedLines.map((line, i) => {
+        const lineNum = startIdx + i + 1;
+        const padding = String(lines.length).length;
+        return `${String(lineNum).padStart(padding)}\u2502${line}`;
+      }).join("\n");
+      return formatted;
+    } catch (err) {
+      return `Error reading file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var WriteTool = {
+  name: "write",
+  description: "Write content to a file. Creates the file and parent directories if they don't exist.",
+  parameters: import_zod2.z.object({
+    path: import_zod2.z.string().describe("The file path to write to"),
+    content: import_zod2.z.string().describe("The content to write")
+  }),
+  async execute(input) {
+    const { path, content } = input;
+    try {
+      const dir = (0, import_node_path3.dirname)(path);
+      if (!(0, import_node_fs3.existsSync)(dir)) {
+        (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+      }
+      (0, import_node_fs3.writeFileSync)(path, content, "utf-8");
+      return `Successfully wrote ${content.length} bytes to ${path}`;
+    } catch (err) {
+      return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var EditTool = {
+  name: "edit",
+  description: "Replace text in a file. The old_string must be unique in the file unless replace_all is true.",
+  parameters: import_zod2.z.object({
+    path: import_zod2.z.string().describe("The file path to edit"),
+    old_string: import_zod2.z.string().describe("The text to find and replace"),
+    new_string: import_zod2.z.string().describe("The replacement text"),
+    replace_all: import_zod2.z.boolean().optional().describe("Replace all occurrences (default: false)")
+  }),
+  async execute(input) {
+    const { path, old_string, new_string, replace_all = false } = input;
+    if (!(0, import_node_fs3.existsSync)(path)) {
+      return `Error: File not found: ${path}`;
+    }
+    try {
+      const content = (0, import_node_fs3.readFileSync)(path, "utf-8");
+      const count = content.split(old_string).length - 1;
+      if (count === 0) {
+        return `Error: old_string not found in file`;
+      }
+      if (count > 1 && !replace_all) {
+        return `Error: old_string found ${count} times. Use replace_all=true to replace all, or provide a more specific string.`;
+      }
+      const newContent = replace_all ? content.split(old_string).join(new_string) : content.replace(old_string, new_string);
+      (0, import_node_fs3.writeFileSync)(path, newContent, "utf-8");
+      const replacements = replace_all ? count : 1;
+      return `Successfully replaced ${replacements} occurrence(s) in ${path}`;
+    } catch (err) {
+      return `Error editing file: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var GlobTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns a list of matching file paths.",
+  parameters: import_zod2.z.object({
+    pattern: import_zod2.z.string().describe('The glob pattern (e.g., "**/*.ts", "src/**/*.js")'),
+    path: import_zod2.z.string().optional().describe("The directory to search in (default: current directory)")
+  }),
+  async execute(input) {
+    const { pattern, path: basePath = "." } = input;
+    try {
+      const files = await glob(pattern, basePath);
+      if (files.length === 0) {
+        return "No files matched the pattern";
+      }
+      const maxResults = 100;
+      const limited = files.slice(0, maxResults);
+      const result = limited.join("\n");
+      if (files.length > maxResults) {
+        return `${result}
+
+... and ${files.length - maxResults} more files`;
+      }
+      return result;
+    } catch (err) {
+      return `Error searching files: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var GrepTool = {
+  name: "grep",
+  description: "Search for a pattern in files. Returns matching lines with file paths and line numbers.",
+  parameters: import_zod2.z.object({
+    pattern: import_zod2.z.string().describe("The regex pattern to search for"),
+    path: import_zod2.z.string().optional().describe("The directory to search in (default: current directory)"),
+    glob: import_zod2.z.string().optional().describe('File pattern to filter (e.g., "*.ts")')
+  }),
+  async execute(input) {
+    const { pattern, path: basePath = ".", glob: fileGlob } = input;
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const results = [];
+      const maxResults = 50;
+      const searchGlob = fileGlob || "**/*";
+      const files = await glob(searchGlob, basePath);
+      outer: for (const file of files) {
+        const fullPath = (0, import_node_path3.resolve)(basePath, file);
+        try {
+          const stat = (0, import_node_fs3.statSync)(fullPath);
+          if (stat.isDirectory()) continue;
+          if (stat.size > 1024 * 1024) continue;
+        } catch {
+          continue;
+        }
+        try {
+          const content = (0, import_node_fs3.readFileSync)(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+              results.push(`${file}:${i + 1}: ${lines[i].trim()}`);
+              regex.lastIndex = 0;
+              if (results.length >= maxResults) break outer;
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      if (results.length === 0) {
+        return "No matches found";
+      }
+      return results.join("\n");
+    } catch (err) {
+      return `Error searching: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var BashTool = {
+  name: "bash",
+  description: "Execute a shell command and return the output.",
+  parameters: import_zod2.z.object({
+    command: import_zod2.z.string().describe("The command to execute"),
+    timeout: import_zod2.z.number().optional().describe("Timeout in milliseconds (default: 30000)")
+  }),
+  async execute(input) {
+    const { command, timeout = 3e4 } = input;
+    return new Promise((resolve3) => {
+      try {
+        const result = (0, import_node_child_process.execSync)(command, {
+          encoding: "utf-8",
+          timeout,
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        resolve3(result || "(no output)");
+      } catch (err) {
+        const error = err;
+        if (error.stdout || error.stderr) {
+          resolve3(`${error.stdout || ""}${error.stderr || ""}`);
+        } else {
+          resolve3(`Error: ${error.message || String(err)}`);
+        }
+      }
+    });
+  }
+};
+var ListTool = {
+  name: "ls",
+  description: "List the contents of a directory.",
+  parameters: import_zod2.z.object({
+    path: import_zod2.z.string().optional().describe("The directory path (default: current directory)"),
+    all: import_zod2.z.boolean().optional().describe("Include hidden files (default: false)")
+  }),
+  async execute(input) {
+    const { path: dirPath = ".", all = false } = input;
+    try {
+      if (!(0, import_node_fs3.existsSync)(dirPath)) {
+        return `Error: Directory not found: ${dirPath}`;
+      }
+      const entries = (0, import_node_fs3.readdirSync)(dirPath, { withFileTypes: true });
+      const filtered = all ? entries : entries.filter((e) => !e.name.startsWith("."));
+      const formatted = filtered.map((entry) => {
+        const suffix = entry.isDirectory() ? "/" : "";
+        return `${entry.name}${suffix}`;
+      });
+      return formatted.sort().join("\n");
+    } catch (err) {
+      return `Error listing directory: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+};
+var BUILTIN_TOOLS = [
+  ReadTool,
+  WriteTool,
+  EditTool,
+  GlobTool,
+  GrepTool,
+  BashTool,
+  ListTool
+];
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const tool2 of BUILTIN_TOOLS) {
+      this.register(tool2);
+    }
+  }
+  /**
+   * Register a tool
+   */
+  register(tool2) {
+    this.tools.set(tool2.name, tool2);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregister(name) {
+    this.tools.delete(name);
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  all() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Execute a tool
+   */
+  async execute(name, input) {
+    const tool2 = this.get(name);
+    if (!tool2) {
+      return {
+        success: false,
+        output: "",
+        error: `Unknown tool: ${name}`
+      };
+    }
+    try {
+      const validated = tool2.parameters.parse(input);
+      const output = await tool2.execute(validated);
+      return {
+        success: true,
+        output
+      };
+    } catch (err) {
+      return {
+        success: false,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+function createToolRegistry() {
+  return new ToolRegistry();
+}
+
+// src/agent/index.ts
+var DEFAULT_SYSTEM_PROMPT = `You are Kaldi, a helpful AI coding assistant. You're a Great Pyrenees who loves helping developers write great code.
+
+You have access to tools to read, write, and edit files, search the codebase, and execute commands. Use these tools to help the user with their coding tasks.
+
+When making changes:
+- Read files before editing them to understand the context
+- Make minimal, focused changes
+- Explain what you're doing and why
+- Be careful with destructive operations
+
+Be friendly, helpful, and thorough in your responses.`;
+async function* runAgentLoop(state) {
+  const {
+    messages,
+    provider,
+    tools,
+    hooks,
+    permissions,
+    systemPrompt = DEFAULT_SYSTEM_PROMPT,
+    maxTurns = 100,
+    onPermissionRequest
+  } = state;
+  let turns = 0;
+  while (turns < maxTurns) {
+    turns++;
+    yield { type: "thinking" };
+    if (hooks) {
+      const hookResult = await hooks.run("PreToolUse", {
+        messages,
+        turn: turns
+      });
+      if (hookResult.blocked) {
+        yield { type: "error", error: hookResult.reason || "Blocked by hook" };
+        return;
+      }
+    }
+    let response;
+    try {
+      response = await provider.chat({
+        model: provider.model,
+        messages,
+        tools: tools.all(),
+        systemPrompt
+      });
+    } catch (err) {
+      yield { type: "error", error: err instanceof Error ? err.message : String(err) };
+      return;
+    }
+    if (response.text) {
+      yield { type: "text", content: response.text };
+    }
+    if (response.toolCalls.length === 0) {
+      yield { type: "done", response };
+      return;
+    }
+    const toolResults = [];
+    for (const toolCall of response.toolCalls) {
+      yield {
+        type: "tool_start",
+        name: toolCall.name,
+        input: toolCall.input
+      };
+      if (permissions) {
+        const allowed = await permissions.check(toolCall.name, toolCall.input);
+        if (!allowed.permitted) {
+          if (onPermissionRequest) {
+            const granted = await onPermissionRequest(toolCall.name, toolCall.input);
+            if (!granted) {
+              yield {
+                type: "tool_denied",
+                name: toolCall.name,
+                reason: "Permission denied by user"
+              };
+              toolResults.push({
+                tool_use_id: toolCall.id,
+                content: "Permission denied by user"
+              });
+              continue;
+            }
+          } else {
+            yield {
+              type: "tool_denied",
+              name: toolCall.name,
+              reason: allowed.reason || "Permission denied"
+            };
+            toolResults.push({
+              tool_use_id: toolCall.id,
+              content: allowed.reason || "Permission denied"
+            });
+            continue;
+          }
+        }
+      }
+      const result = await tools.execute(toolCall.name, toolCall.input);
+      yield {
+        type: "tool_result",
+        name: toolCall.name,
+        result
+      };
+      if (hooks) {
+        await hooks.run("PostToolUse", {
+          tool: toolCall.name,
+          input: toolCall.input,
+          result
+        });
+      }
+      toolResults.push({
+        tool_use_id: toolCall.id,
+        content: result.success ? result.output : `Error: ${result.error}`
+      });
+    }
+    messages.push({
+      role: "assistant",
+      content: [
+        ...response.text ? [{ type: "text", text: response.text }] : [],
+        ...response.toolCalls.map((tc) => ({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: tc.input
+        }))
+      ]
+    });
+    messages.push({
+      role: "user",
+      content: toolResults.map((tr) => ({
+        type: "tool_result",
+        tool_use_id: tr.tool_use_id,
+        content: tr.content
+      }))
+    });
+  }
+  yield { type: "error", error: `Max turns (${maxTurns}) reached` };
+}
+async function runAgent(state) {
+  const events = [];
+  for await (const event of runAgentLoop(state)) {
+    events.push(event);
+  }
+  return {
+    events,
+    messages: state.messages
+  };
+}
+function createAgentState(provider, tools, options) {
+  return {
+    messages: [],
+    provider,
+    tools,
+    ...options
+  };
+}
+
+// src/hooks/index.ts
+var import_node_child_process2 = require("child_process");
+async function runCommandHook(command, context) {
+  try {
+    const input = JSON.stringify(context);
+    const output = (0, import_node_child_process2.execSync)(command, {
+      encoding: "utf-8",
+      input,
+      timeout: 3e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    try {
+      const result = JSON.parse(output);
+      return {
+        blocked: result.blocked === true,
+        reason: result.reason,
+        output: result.output || output
+      };
+    } catch {
+      return {
+        blocked: false,
+        output
+      };
+    }
+  } catch (err) {
+    const error = err;
+    if (error.status === 2) {
+      return {
+        blocked: true,
+        reason: error.message || "Hook blocked execution"
+      };
+    }
+    return {
+      blocked: false,
+      output: error.message || String(err)
+    };
+  }
+}
+async function runPromptHook(prompt, context) {
+  return {
+    blocked: false,
+    output: `Prompt hook: ${prompt}`
+  };
+}
+var HooksRunner = class {
+  hooks = /* @__PURE__ */ new Map();
+  constructor(hooks) {
+    if (hooks) {
+      for (const [event, eventHooks] of Object.entries(hooks)) {
+        this.hooks.set(event, eventHooks);
+      }
+    }
+  }
+  /**
+   * Add a hook
+   */
+  add(event, hook) {
+    const existing = this.hooks.get(event) || [];
+    existing.push(hook);
+    this.hooks.set(event, existing);
+  }
+  /**
+   * Remove all hooks for an event
+   */
+  clear(event) {
+    this.hooks.delete(event);
+  }
+  /**
+   * Run all hooks for an event
+   */
+  async run(event, context = {}) {
+    const hooks = this.hooks.get(event) || [];
+    const fullContext = { event, ...context };
+    for (const hook of hooks) {
+      if (hook.matcher && context.tool) {
+        const pattern = new RegExp(hook.matcher);
+        if (!pattern.test(context.tool)) {
+          continue;
+        }
+      }
+      let result;
+      switch (hook.type) {
+        case "command":
+          if (hook.command) {
+            result = await runCommandHook(hook.command, fullContext);
+          } else {
+            result = { blocked: false };
+          }
+          break;
+        case "prompt":
+          if (hook.prompt) {
+            result = await runPromptHook(hook.prompt, fullContext);
+          } else {
+            result = { blocked: false };
+          }
+          break;
+        case "agent":
+          result = { blocked: false };
+          break;
+        default:
+          result = { blocked: false };
+      }
+      if (result.blocked) {
+        return result;
+      }
+    }
+    return { blocked: false };
+  }
+  /**
+   * Get all hooks for an event
+   */
+  get(event) {
+    return this.hooks.get(event) || [];
+  }
+};
+function createHooksRunner(hooks) {
+  return new HooksRunner(hooks);
+}
+
+// src/permissions/index.ts
+function matchPattern(pattern, toolName, input) {
+  if (!pattern.includes("(")) {
+    return pattern === toolName || pattern === "*";
+  }
+  const match = pattern.match(/^(\w+)\((.*)\)$/);
+  if (!match) return false;
+  const [, name, argPattern] = match;
+  if (name !== toolName && name !== "*") {
+    return false;
+  }
+  const argRegex = new RegExp(argPattern);
+  for (const value of Object.values(input)) {
+    if (typeof value === "string" && argRegex.test(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+var PermissionChecker = class {
+  config;
+  constructor(config) {
+    this.config = config || { yolo: false };
+  }
+  /**
+   * Check if a tool execution is permitted
+   */
+  async check(toolName, input) {
+    if (this.config.yolo) {
+      return { permitted: true };
+    }
+    if (this.config.disallowedTools) {
+      for (const pattern of this.config.disallowedTools) {
+        if (matchPattern(pattern, toolName, input)) {
+          return {
+            permitted: false,
+            reason: `Tool ${toolName} is disallowed by pattern: ${pattern}`
+          };
+        }
+      }
+    }
+    if (this.config.autoApprove) {
+      for (const pattern of this.config.autoApprove) {
+        if (matchPattern(pattern, toolName, input)) {
+          return { permitted: true };
+        }
+      }
+    }
+    if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+      for (const pattern of this.config.allowedTools) {
+        if (matchPattern(pattern, toolName, input)) {
+          return { permitted: true };
+        }
+      }
+      return {
+        permitted: false,
+        reason: `Tool ${toolName} is not in allowed list`,
+        requiresConfirmation: true
+      };
+    }
+    const dangerousTools = ["bash", "write", "edit"];
+    if (dangerousTools.includes(toolName)) {
+      return {
+        permitted: false,
+        reason: `Tool ${toolName} requires confirmation`,
+        requiresConfirmation: true
+      };
+    }
+    return { permitted: true };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Enable YOLO mode
+   */
+  enableYolo() {
+    this.config.yolo = true;
+  }
+  /**
+   * Disable YOLO mode
+   */
+  disableYolo() {
+    this.config.yolo = false;
+  }
+  /**
+   * Add an auto-approve pattern
+   */
+  addAutoApprove(pattern) {
+    if (!this.config.autoApprove) {
+      this.config.autoApprove = [];
+    }
+    this.config.autoApprove.push(pattern);
+  }
+};
+function createPermissionChecker(config) {
+  return new PermissionChecker(config);
+}
+
+// src/session/index.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+var import_node_crypto = require("crypto");
+function getSessionPath(id) {
+  const dir = getSessionsDir();
+  return (0, import_node_path4.join)(dir, `${id}.jsonl`);
+}
+function ensureSessionsDir() {
+  const dir = getSessionsDir();
+  if (!(0, import_node_fs4.existsSync)(dir)) {
+    (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  }
+}
+function createSession(options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: (0, import_node_crypto.randomUUID)(),
+    name: options?.name,
+    createdAt: now,
+    updatedAt: now,
+    projectPath: options?.projectPath,
+    model: options?.model,
+    messageCount: 0,
+    messages: []
+  };
+}
+function saveSession(session) {
+  ensureSessionsDir();
+  const path = getSessionPath(session.id);
+  const lines = [];
+  const meta = {
+    type: "meta",
+    timestamp: session.updatedAt,
+    data: {
+      id: session.id,
+      name: session.name,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      projectPath: session.projectPath,
+      model: session.model,
+      messageCount: session.messages.length
+    }
+  };
+  lines.push(JSON.stringify(meta));
+  for (const message of session.messages) {
+    const entry = {
+      type: "message",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: message
+    };
+    lines.push(JSON.stringify(entry));
+  }
+  (0, import_node_fs4.writeFileSync)(path, lines.join("\n") + "\n");
+}
+function appendMessage(sessionId, message) {
+  ensureSessionsDir();
+  const path = getSessionPath(sessionId);
+  const entry = {
+    type: "message",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data: message
+  };
+  const line = JSON.stringify(entry) + "\n";
+  if ((0, import_node_fs4.existsSync)(path)) {
+    const content = (0, import_node_fs4.readFileSync)(path, "utf-8");
+    (0, import_node_fs4.writeFileSync)(path, content + line);
+  } else {
+    (0, import_node_fs4.writeFileSync)(path, line);
+  }
+}
+function loadSession(id) {
+  const path = getSessionPath(id);
+  if (!(0, import_node_fs4.existsSync)(path)) {
+    return null;
+  }
+  const content = (0, import_node_fs4.readFileSync)(path, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  let meta = null;
+  const messages = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "meta") {
+        meta = entry.data;
+      } else if (entry.type === "message") {
+        messages.push(entry.data);
+      }
+    } catch {
+    }
+  }
+  if (!meta) {
+    meta = {
+      id,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      messageCount: messages.length
+    };
+  }
+  return {
+    ...meta,
+    messages
+  };
+}
+function listSessions() {
+  ensureSessionsDir();
+  const dir = getSessionsDir();
+  const files = (0, import_node_fs4.readdirSync)(dir).filter((f) => f.endsWith(".jsonl"));
+  const sessions = [];
+  for (const file of files) {
+    const id = file.replace(".jsonl", "");
+    const session = loadSession(id);
+    if (session) {
+      sessions.push({
+        id: session.id,
+        name: session.name,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        projectPath: session.projectPath,
+        model: session.model,
+        messageCount: session.messageCount
+      });
+    }
+  }
+  return sessions.sort(
+    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+function deleteSession(id) {
+  const path = getSessionPath(id);
+  if ((0, import_node_fs4.existsSync)(path)) {
+    (0, import_node_fs4.unlinkSync)(path);
+    return true;
+  }
+  return false;
+}
+function getRecentSession() {
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    return null;
+  }
+  return loadSession(sessions[0].id);
+}
+function forkSession(id) {
+  const original = loadSession(id);
+  if (!original) {
+    return null;
+  }
+  const forked = createSession({
+    name: original.name ? `${original.name} (fork)` : void 0,
+    projectPath: original.projectPath,
+    model: original.model
+  });
+  forked.messages = [...original.messages];
+  forked.messageCount = original.messageCount;
+  saveSession(forked);
+  return forked;
+}
+var SessionManager = class {
+  currentSession = null;
+  /**
+   * Start a new session
+   */
+  start(options) {
+    this.currentSession = createSession(options);
+    return this.currentSession;
+  }
+  /**
+   * Resume an existing session
+   */
+  resume(id) {
+    const session = loadSession(id);
+    if (session) {
+      this.currentSession = session;
+    }
+    return session;
+  }
+  /**
+   * Resume the most recent session
+   */
+  resumeRecent() {
+    const session = getRecentSession();
+    if (session) {
+      this.currentSession = session;
+    }
+    return session;
+  }
+  /**
+   * Get current session
+   */
+  get current() {
+    return this.currentSession;
+  }
+  /**
+   * Add a message to current session
+   */
+  addMessage(message) {
+    if (!this.currentSession) {
+      throw new Error("No active session");
+    }
+    this.currentSession.messages.push(message);
+    this.currentSession.messageCount = this.currentSession.messages.length;
+    this.currentSession.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  /**
+   * Save current session
+   */
+  save() {
+    if (this.currentSession) {
+      saveSession(this.currentSession);
+    }
+  }
+  /**
+   * Clear current session messages
+   */
+  clear() {
+    if (this.currentSession) {
+      this.currentSession.messages = [];
+      this.currentSession.messageCount = 0;
+      this.currentSession.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  /**
+   * End current session
+   */
+  end() {
+    if (this.currentSession) {
+      this.save();
+      this.currentSession = null;
+    }
+  }
+};
+function createSessionManager() {
+  return new SessionManager();
+}
+
+// src/mcp/index.ts
+var import_node_child_process3 = require("child_process");
+var import_node_events = require("events");
+var import_zod3 = require("zod");
+var MCPConnection = class extends import_node_events.EventEmitter {
+  server;
+  process = null;
+  messageId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  tools = [];
+  initialized = false;
+  constructor(server) {
+    super();
+    this.server = server;
+  }
+  /**
+   * Connect to the MCP server
+   */
+  async connect() {
+    if (this.server.transport !== "stdio") {
+      throw new Error(`Transport ${this.server.transport} not yet supported`);
+    }
+    if (!this.server.command) {
+      throw new Error("Command is required for stdio transport");
+    }
+    this.process = (0, import_node_child_process3.spawn)(this.server.command, this.server.args || [], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        ...this.server.env
+      }
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.handleData(data.toString());
+    });
+    this.process.stderr?.on("data", (data) => {
+      this.emit("log", data.toString());
+    });
+    this.process.on("exit", (code) => {
+      this.emit("exit", code);
+      this.initialized = false;
+    });
+    await this.initialize();
+  }
+  /**
+   * Handle incoming data
+   */
+  handleData(data) {
+    this.buffer += data;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const message = JSON.parse(line);
+        if ("id" in message && this.pendingRequests.has(message.id)) {
+          const pending = this.pendingRequests.get(message.id);
+          this.pendingRequests.delete(message.id);
+          if (message.error) {
+            pending.reject(new Error(message.error.message));
+          } else {
+            pending.resolve(message.result);
+          }
+        } else if ("method" in message && !("id" in message)) {
+          this.emit("notification", message);
+        }
+      } catch (err) {
+        this.emit("error", err);
+      }
+    }
+  }
+  /**
+   * Send a request and wait for response
+   */
+  async request(method, params) {
+    if (!this.process?.stdin) {
+      throw new Error("Not connected");
+    }
+    const id = ++this.messageId;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolve3, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve3, reject });
+      this.process.stdin.write(JSON.stringify(request) + "\n");
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error("Request timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Initialize the MCP connection
+   */
+  async initialize() {
+    await this.request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {}
+      },
+      clientInfo: {
+        name: "puppuccino",
+        version: "0.1.0"
+      }
+    });
+    this.process?.stdin?.write(JSON.stringify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    }) + "\n");
+    const result = await this.request("tools/list");
+    this.tools = result.tools || [];
+    this.initialized = true;
+    this.emit("ready");
+  }
+  /**
+   * Get tools from this server
+   */
+  getTools() {
+    return this.tools.map((t) => this.convertTool(t));
+  }
+  /**
+   * Convert MCP tool to our Tool format
+   */
+  convertTool(mcpTool) {
+    const properties = {};
+    for (const [key, schema] of Object.entries(mcpTool.inputSchema.properties)) {
+      const s = schema;
+      let zodType;
+      switch (s.type) {
+        case "string":
+          zodType = import_zod3.z.string();
+          break;
+        case "number":
+          zodType = import_zod3.z.number();
+          break;
+        case "boolean":
+          zodType = import_zod3.z.boolean();
+          break;
+        case "array":
+          zodType = import_zod3.z.array(import_zod3.z.unknown());
+          break;
+        case "object":
+          zodType = import_zod3.z.object({});
+          break;
+        default:
+          zodType = import_zod3.z.unknown();
+      }
+      if (s.description) {
+        zodType = zodType.describe(s.description);
+      }
+      if (!mcpTool.inputSchema.required?.includes(key)) {
+        zodType = zodType.optional();
+      }
+      properties[key] = zodType;
+    }
+    const parameters = import_zod3.z.object(properties);
+    return {
+      name: `mcp__${this.server.name}__${mcpTool.name}`,
+      description: mcpTool.description,
+      parameters,
+      execute: async (input) => {
+        const result = await this.callTool(mcpTool.name, input);
+        return typeof result === "string" ? result : JSON.stringify(result);
+      }
+    };
+  }
+  /**
+   * Call a tool on this server
+   */
+  async callTool(name, input) {
+    const result = await this.request(
+      "tools/call",
+      { name, arguments: input }
+    );
+    const textContent = result.content?.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+    return textContent || result;
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.initialized = false;
+    this.tools = [];
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.initialized;
+  }
+};
+var MCPClient = class {
+  connections = /* @__PURE__ */ new Map();
+  /**
+   * Add and connect to an MCP server
+   */
+  async addServer(server) {
+    if (!server.enabled) return;
+    const connection = new MCPConnection(server);
+    await connection.connect();
+    this.connections.set(server.name, connection);
+  }
+  /**
+   * Remove an MCP server
+   */
+  removeServer(name) {
+    const connection = this.connections.get(name);
+    if (connection) {
+      connection.disconnect();
+      this.connections.delete(name);
+    }
+  }
+  /**
+   * Get all tools from all servers
+   */
+  getTools() {
+    const tools = [];
+    for (const connection of this.connections.values()) {
+      if (connection.isConnected) {
+        tools.push(...connection.getTools());
+      }
+    }
+    return tools;
+  }
+  /**
+   * Call a tool (parses the mcp__server__tool format)
+   */
+  async callTool(name, input) {
+    const parts = name.split("__");
+    if (parts.length !== 3 || parts[0] !== "mcp") {
+      throw new Error(`Invalid MCP tool name: ${name}`);
+    }
+    const [, serverName, toolName] = parts;
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new Error(`MCP server not found: ${serverName}`);
+    }
+    return connection.callTool(toolName, input);
+  }
+  /**
+   * Disconnect all servers
+   */
+  disconnectAll() {
+    for (const connection of this.connections.values()) {
+      connection.disconnect();
+    }
+    this.connections.clear();
+  }
+  /**
+   * Get connected server names
+   */
+  get servers() {
+    return Array.from(this.connections.keys());
+  }
+};
+function createMCPClient() {
+  return new MCPClient();
+}
+
+// src/skills/index.ts
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
+var import_node_os2 = require("os");
+var SKILL_LOCATIONS = [
+  // Personal skills
+  (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".puppuccino", "skills"),
+  (0, import_node_path5.join)((0, import_node_os2.homedir)(), ".config", "puppuccino", "skills"),
+  // Project skills (will be prefixed with project path)
+  ".puppuccino/skills"
+];
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { meta: {}, content };
+  }
+  const [, yaml, rest] = match;
+  const meta = {};
+  for (const line of yaml.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value === "true") value = true;
+    else if (value === "false") value = false;
+    if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+      value = value.slice(1, -1).split(",").map((s) => s.trim());
+    }
+    const camelKey = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    meta[camelKey] = value;
+  }
+  return { meta, content: rest.trim() };
+}
+function loadSkillFromDir(dir) {
+  const skillFile = (0, import_node_path5.join)(dir, "SKILL.md");
+  if (!(0, import_node_fs5.existsSync)(skillFile)) {
+    return null;
+  }
+  const content = (0, import_node_fs5.readFileSync)(skillFile, "utf-8");
+  const { meta, content: skillContent } = parseFrontmatter(content);
+  const name = meta.name || (0, import_node_path5.dirname)(dir).split("/").pop() || "";
+  return {
+    name,
+    description: meta.description,
+    disableModelInvocation: meta.disableModelInvocation,
+    userInvocable: meta.userInvocable !== false,
+    // default true
+    allowedTools: meta.allowedTools,
+    model: meta.model,
+    context: meta.context,
+    agent: meta.agent,
+    content: skillContent,
+    path: skillFile
+  };
+}
+function loadSkillsFromDir(dir) {
+  if (!(0, import_node_fs5.existsSync)(dir)) {
+    return [];
+  }
+  const skills = [];
+  try {
+    const entries = (0, import_node_fs5.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skill = loadSkillFromDir((0, import_node_path5.join)(dir, entry.name));
+        if (skill) {
+          skills.push(skill);
+        }
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+var SkillsLoader = class {
+  skills = /* @__PURE__ */ new Map();
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.reload();
+  }
+  /**
+   * Reload all skills
+   */
+  reload() {
+    this.skills.clear();
+    const locations = [...SKILL_LOCATIONS].reverse();
+    for (const location of locations) {
+      let dir;
+      if (location.startsWith(".")) {
+        if (!this.projectPath) continue;
+        dir = (0, import_node_path5.join)(this.projectPath, location);
+      } else {
+        dir = location;
+      }
+      const skills = loadSkillsFromDir(dir);
+      for (const skill of skills) {
+        this.skills.set(skill.name, skill);
+      }
+    }
+  }
+  /**
+   * Get a skill by name
+   */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /**
+   * Get all skills
+   */
+  all() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * Get user-invocable skills
+   */
+  userInvocable() {
+    return this.all().filter((s) => s.userInvocable !== false);
+  }
+  /**
+   * Get model-invocable skills
+   */
+  modelInvocable() {
+    return this.all().filter((s) => !s.disableModelInvocation);
+  }
+  /**
+   * Check if a skill exists
+   */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /**
+   * Expand a skill's content with arguments
+   */
+  expand(name, args) {
+    const skill = this.get(name);
+    if (!skill) return null;
+    let content = skill.content;
+    if (args) {
+      const argParts = args.split(/\s+/);
+      content = content.replace(/\$ARGUMENTS/g, args);
+      content = content.replace(/\$ARGUMENTS\[(\d+)\]/g, (_, n) => argParts[parseInt(n)] || "");
+      content = content.replace(/\$(\d+)/g, (_, n) => argParts[parseInt(n) - 1] || "");
+    }
+    return content;
+  }
+};
+function createSkillsLoader(projectPath) {
+  return new SkillsLoader(projectPath);
+}
+
+// src/context/index.ts
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  "coverage",
+  "__pycache__",
+  ".pytest_cache",
+  "venv",
+  ".venv"
+]);
+function buildTree(dir, depth = 3, current = 0) {
+  if (current >= depth) return [];
+  try {
+    const entries = (0, import_node_fs6.readdirSync)(dir, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || IGNORED_DIRS.has(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        result.push({
+          name: entry.name,
+          type: "directory",
+          children: buildTree((0, import_node_path6.join)(dir, entry.name), depth, current + 1)
+        });
+      } else {
+        result.push({
+          name: entry.name,
+          type: "file"
+        });
+      }
+    }
+    return result.sort((a, b) => {
+      if (a.type === b.type) return a.name.localeCompare(b.name);
+      return a.type === "directory" ? -1 : 1;
+    });
+  } catch {
+    return [];
+  }
+}
+function formatTree(tree, prefix = "") {
+  const lines = [];
+  for (let i = 0; i < tree.length; i++) {
+    const item = tree[i];
+    const isLast = i === tree.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const childPrefix = isLast ? "    " : "\u2502   ";
+    const suffix = item.type === "directory" ? "/" : "";
+    lines.push(`${prefix}${connector}${item.name}${suffix}`);
+    if (item.children && item.children.length > 0) {
+      lines.push(formatTree(item.children, prefix + childPrefix));
+    }
+  }
+  return lines.join("\n");
+}
+function findGitRoot(dir) {
+  let current = dir;
+  while (current !== "/") {
+    if ((0, import_node_fs6.existsSync)((0, import_node_path6.join)(current, ".git"))) {
+      return current;
+    }
+    current = (0, import_node_path6.join)(current, "..");
+  }
+  return void 0;
+}
+function loadProjectContext(projectPath) {
+  const name = (0, import_node_path6.basename)(projectPath);
+  const gitRoot = findGitRoot(projectPath);
+  let packageJson;
+  const packageJsonPath = (0, import_node_path6.join)(projectPath, "package.json");
+  if ((0, import_node_fs6.existsSync)(packageJsonPath)) {
+    try {
+      packageJson = JSON.parse((0, import_node_fs6.readFileSync)(packageJsonPath, "utf-8"));
+    } catch {
+    }
+  }
+  let readme;
+  const readmeNames = ["README.md", "README.txt", "README", "readme.md"];
+  for (const readmeName of readmeNames) {
+    const readmePath = (0, import_node_path6.join)(projectPath, readmeName);
+    if ((0, import_node_fs6.existsSync)(readmePath)) {
+      try {
+        readme = (0, import_node_fs6.readFileSync)(readmePath, "utf-8");
+        if (readme.length > 2e3) {
+          readme = readme.slice(0, 2e3) + "\n...(truncated)";
+        }
+      } catch {
+      }
+      break;
+    }
+  }
+  const tree = buildTree(projectPath);
+  const structure = formatTree(tree);
+  return {
+    path: projectPath,
+    name,
+    gitRoot,
+    packageJson,
+    readme,
+    structure
+  };
+}
+function formatProjectContext(context) {
+  const sections = [];
+  sections.push(`## Project: ${context.name}`);
+  sections.push(`Path: ${context.path}`);
+  if (context.gitRoot) {
+    sections.push(`Git root: ${context.gitRoot}`);
+  }
+  if (context.packageJson) {
+    const pkg = context.packageJson;
+    if (pkg.description) {
+      sections.push(`
+Description: ${pkg.description}`);
+    }
+    if (pkg.scripts) {
+      sections.push(`
+Available scripts: ${Object.keys(pkg.scripts).join(", ")}`);
+    }
+  }
+  sections.push(`
+## Project Structure
+\`\`\`
+${context.structure}
+\`\`\``);
+  if (context.readme) {
+    sections.push(`
+## README
+${context.readme}`);
+  }
+  return sections.join("\n");
+}
+var Memory = class {
+  entries = [];
+  maxEntries = 100;
+  /**
+   * Add an entry
+   */
+  add(type, content) {
+    this.entries.push({
+      type,
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.entries.length > this.maxEntries) {
+      this.entries = this.entries.slice(-this.maxEntries);
+    }
+  }
+  /**
+   * Get all entries
+   */
+  all() {
+    return [...this.entries];
+  }
+  /**
+   * Get entries by type
+   */
+  byType(type) {
+    return this.entries.filter((e) => e.type === type);
+  }
+  /**
+   * Format memory for system prompt
+   */
+  format() {
+    if (this.entries.length === 0) return "";
+    const sections = ["## Memory"];
+    const facts = this.byType("fact");
+    if (facts.length > 0) {
+      sections.push("\n### Facts");
+      for (const fact of facts) {
+        sections.push(`- ${fact.content}`);
+      }
+    }
+    const preferences = this.byType("preference");
+    if (preferences.length > 0) {
+      sections.push("\n### User Preferences");
+      for (const pref of preferences) {
+        sections.push(`- ${pref.content}`);
+      }
+    }
+    const summaries = this.byType("summary");
+    if (summaries.length > 0) {
+      sections.push("\n### Previous Context");
+      for (const summary of summaries.slice(-3)) {
+        sections.push(`- ${summary.content}`);
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.entries = [];
+  }
+  /**
+   * Export entries
+   */
+  export() {
+    return [...this.entries];
+  }
+  /**
+   * Import entries
+   */
+  import(entries) {
+    this.entries = [...entries];
+  }
+};
+function createMemory() {
+  return new Memory();
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILTIN_TOOLS,
+  BashTool,
+  CONFIG_PATHS,
+  ConfigSchema,
+  DEFAULT_SYSTEM_PROMPT,
+  EditTool,
+  GlobTool,
+  GrepTool,
+  HookSchema,
+  HooksRunner,
+  ListTool,
+  MCPClient,
+  MCPConnection,
+  MCPServerSchema,
+  Memory,
+  PermissionChecker,
+  PermissionsSchema,
+  Provider,
+  ReadTool,
+  SessionManager,
+  SkillsLoader,
+  ToolRegistry,
+  VERSION,
+  WriteTool,
+  appendMessage,
+  createAgentState,
+  createHooksRunner,
+  createMCPClient,
+  createMemory,
+  createPermissionChecker,
+  createProvider,
+  createProviderInstance,
+  createSession,
+  createSessionManager,
+  createSkillsLoader,
+  createToolRegistry,
+  deleteSession,
+  forkSession,
+  formatProjectContext,
+  getDataDir,
+  getRecentSession,
+  getSessionsDir,
+  getUserConfigPath,
+  listSessions,
+  loadConfig,
+  loadProjectContext,
+  loadSession,
+  runAgent,
+  runAgentLoop,
+  saveConfig,
+  saveSession
+});