cliskill 1.0.0

package/dist/index.js

@@ -0,0 +1,1658 @@
+import {
+  AdapterRegistry,
+  AgentTool,
+  ContextCompactor,
+  CostTracker,
+  DEFAULT_MEMORY_DIR,
+  EnhancedMemoryStore,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  GenericCompatAdapter,
+  InkApp,
+  LspTool,
+  MessageList,
+  QueryEngine,
+  Spinner,
+  StatusBar,
+  StreamingToolExecutor,
+  ToolRegistry,
+  WebSearchTool,
+  analyzeTokenBudget,
+  createDefaultToolRegistry,
+  estimateMessagesTokens,
+  estimateTokens,
+  formatAnsiMessage,
+  renderInkApp,
+  runAgentLoop,
+  runCli
+} from "./chunk-ULZHJVWD.js";
+import {
+  getGlobalSkillsDir,
+  getHistoryPath
+} from "./chunk-AJENHWD3.js";
+
+// src/memory/store.ts
+import { readFile, writeFile, mkdir, readdir, stat, unlink } from "fs/promises";
+import { join, resolve } from "path";
+import { existsSync } from "fs";
+var DEFAULT_CONFIG = {
+  memoryDir: DEFAULT_MEMORY_DIR,
+  maxEntrypointSize: 25e3,
+  maxTopicFiles: 50
+};
+var MemoryStore = class {
+  config;
+  rootDir;
+  cache = /* @__PURE__ */ new Map();
+  loaded = false;
+  constructor(projectRoot, config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.rootDir = resolve(projectRoot, this.config.memoryDir);
+  }
+  /**
+   * Initialize the memory directory structure.
+   */
+  async init() {
+    await mkdir(join(this.rootDir, "topics"), { recursive: true });
+    const entrypointPath = join(this.rootDir, "MEMORY.md");
+    if (!existsSync(entrypointPath)) {
+      await writeFile(
+        entrypointPath,
+        "# Project Memory\n\nThis file contains persistent memory for the AI assistant.\n",
+        "utf-8"
+      );
+    }
+    await this.load();
+  }
+  /**
+   * Load all memories from disk into cache.
+   */
+  async load() {
+    this.cache.clear();
+    const topicsDir = join(this.rootDir, "topics");
+    if (existsSync(topicsDir)) {
+      const files = await readdir(topicsDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const topic = file.replace(".md", "");
+          const filePath = join(topicsDir, file);
+          const content = await readFile(filePath, "utf-8");
+          const fileStat = await stat(filePath);
+          this.cache.set(topic, {
+            id: topic,
+            topic,
+            content,
+            createdAt: fileStat.birthtimeMs,
+            lastAccessedAt: fileStat.mtimeMs
+          });
+        }
+      }
+    }
+    this.loaded = true;
+  }
+  /**
+   * Get a memory by topic.
+   */
+  get(topic) {
+    return this.cache.get(topic);
+  }
+  /**
+   * Get all memories.
+   */
+  getAll() {
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Save a memory entry to disk.
+   */
+  async set(topic, content) {
+    const filePath = join(this.rootDir, "topics", `${topic}.md`);
+    await mkdir(join(this.rootDir, "topics"), { recursive: true });
+    await writeFile(filePath, content, "utf-8");
+    const now = Date.now();
+    const existing = this.cache.get(topic);
+    this.cache.set(topic, {
+      id: topic,
+      topic,
+      content,
+      createdAt: existing?.createdAt ?? now,
+      lastAccessedAt: now
+    });
+  }
+  /**
+   * Delete a memory by topic.
+   */
+  async delete(topic) {
+    const filePath = join(this.rootDir, "topics", `${topic}.md`);
+    if (existsSync(filePath)) {
+      await unlink(filePath);
+      this.cache.delete(topic);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Search memories by keyword.
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter(
+      (entry) => entry.content.toLowerCase().includes(lowerQuery) || entry.topic.toLowerCase().includes(lowerQuery)
+    ).sort((a, b) => b.lastAccessedAt - a.lastAccessedAt);
+  }
+  /**
+   * Get the entrypoint (MEMORY.md) content.
+   */
+  async getEntrypoint() {
+    const entrypointPath = join(this.rootDir, "MEMORY.md");
+    if (existsSync(entrypointPath)) {
+      return readFile(entrypointPath, "utf-8");
+    }
+    return "";
+  }
+  /**
+   * Update the entrypoint (MEMORY.md) content.
+   */
+  async setEntrypoint(content) {
+    if (content.length > this.config.maxEntrypointSize) {
+      content = content.slice(0, this.config.maxEntrypointSize) + "\n\n... (truncated)";
+    }
+    const entrypointPath = join(this.rootDir, "MEMORY.md");
+    await writeFile(entrypointPath, content, "utf-8");
+  }
+  /**
+   * Build a context string from relevant memories for inclusion in system prompt.
+   */
+  async buildContext(query, maxTokens = 2e3) {
+    let memories;
+    if (query) {
+      memories = this.search(query);
+    } else {
+      memories = this.getAll().sort((a, b) => b.lastAccessedAt - a.lastAccessedAt);
+    }
+    const entrypoint = await this.getEntrypoint();
+    let context = "";
+    if (entrypoint) {
+      context += `## Project Memory
+${entrypoint}
+
+`;
+    }
+    for (const memory of memories) {
+      const addition = `### ${memory.topic}
+${memory.content.slice(0, 500)}
+
+`;
+      if ((context.length + addition.length) / 4 > maxTokens) break;
+      context += addition;
+    }
+    return context.trim();
+  }
+};
+
+// src/extensions/skill-loader.ts
+import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+async function loadSkillsFromDir(dir) {
+  if (!existsSync2(dir)) return [];
+  const skills = [];
+  const files = await readdir2(dir);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = join2(dir, file);
+    const content = await readFile2(filePath, "utf-8");
+    const skill = parseSkillMarkdown(content, filePath);
+    if (skill) {
+      skills.push(skill);
+    }
+  }
+  return skills;
+}
+function parseSkillMarkdown(content, sourcePath) {
+  const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    const name = sourcePath ? sourcePath.split(/[\\/]/).pop()?.replace(".md", "") ?? "unnamed" : "unnamed";
+    return {
+      name,
+      description: `Skill: ${name}`,
+      prompt: content.trim(),
+      builtin: false,
+      sourcePath
+    };
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  const metadata = parseSimpleYaml(frontmatter);
+  if (!metadata.name) {
+    metadata.name = sourcePath ? sourcePath.split(/[\\/]/).pop()?.replace(".md", "") ?? "unnamed" : "unnamed";
+  }
+  return {
+    name: metadata.name,
+    description: metadata.description ?? `Skill: ${metadata.name}`,
+    aliases: metadata.aliases ? String(metadata.aliases).replace(/^\[(.+)\]$/, "$1").split(",").map((s) => s.trim()) : void 0,
+    prompt: body.trim(),
+    allowedTools: metadata.allowedTools ? String(metadata.allowedTools).replace(/^\[(.+)\]$/, "$1").split(",").map((s) => s.trim()) : void 0,
+    builtin: false,
+    sourcePath
+  };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    const value = trimmed.slice(colonIndex + 1).trim();
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/extensions/skill-registry.ts
+import { join as join3 } from "path";
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  aliasIndex = /* @__PURE__ */ new Map();
+  /** Register a skill */
+  register(skill) {
+    this.skills.set(skill.name, skill);
+    if (skill.aliases) {
+      for (const alias of skill.aliases) {
+        this.aliasIndex.set(alias.toLowerCase(), skill.name);
+      }
+    }
+  }
+  /** Get a skill by name or alias */
+  get(nameOrAlias) {
+    const aliasTarget = this.aliasIndex.get(nameOrAlias.toLowerCase());
+    return this.skills.get(aliasTarget ?? nameOrAlias);
+  }
+  /** Get all registered skills */
+  getAll() {
+    return Array.from(this.skills.values());
+  }
+  /** Check if a skill exists */
+  has(name) {
+    return this.skills.has(name) || this.aliasIndex.has(name.toLowerCase());
+  }
+  /** Unregister a skill */
+  unregister(name) {
+    const skill = this.skills.get(name);
+    if (skill?.aliases) {
+      for (const alias of skill.aliases) {
+        this.aliasIndex.delete(alias.toLowerCase());
+      }
+    }
+    this.skills.delete(name);
+  }
+  /**
+   * Load skills from a directory.
+   * Returns the number of skills loaded.
+   */
+  async loadFromDir(dir) {
+    const skills = await loadSkillsFromDir(dir);
+    for (const skill of skills) {
+      this.register(skill);
+    }
+    return skills.length;
+  }
+  /**
+   * Load skills from standard locations:
+   * 1. ~/.cliskill/skills/ (global user skills)
+   * 2. .cliskill/skills/ (project skills)
+   */
+  async loadStandardSkills(projectRoot) {
+    let count = 0;
+    const globalDir = getGlobalSkillsDir();
+    count += await this.loadFromDir(globalDir);
+    const projectDir = join3(projectRoot, ".cliskill", "skills");
+    count += await this.loadFromDir(projectDir);
+    return count;
+  }
+  /**
+   * Get skill prompt for injection into system prompt.
+   */
+  getSkillPrompt(nameOrAlias) {
+    const skill = this.get(nameOrAlias);
+    return skill?.prompt;
+  }
+};
+
+// src/safety/permissions.ts
+var PermissionManager = class {
+  mode;
+  rules = [];
+  sessionDecisions = /* @__PURE__ */ new Map();
+  constructor(mode, rules) {
+    this.mode = mode;
+    this.rules = rules ?? [];
+  }
+  /**
+   * Check if a tool operation is allowed.
+   */
+  check(toolName, riskLevel, content) {
+    if (this.mode === "auto-accept") {
+      return { allowed: true, reason: "auto-accept mode" };
+    }
+    if (this.mode === "plan") {
+      if (riskLevel === "readonly") {
+        return { allowed: true, reason: "readonly in plan mode" };
+      }
+      return { allowed: false, reason: `${riskLevel} operations not allowed in plan mode` };
+    }
+    for (const rule of this.rules) {
+      if (this.matchTool(toolName, rule.tool)) {
+        if (!rule.contentPattern || content && this.matchContent(content, rule.contentPattern)) {
+          return {
+            allowed: rule.allow,
+            reason: rule.allow ? `Allowed by rule: ${rule.tool}` : `Denied by rule: ${rule.tool}`
+          };
+        }
+      }
+    }
+    const sessionKey = `${toolName}:${content ?? ""}`;
+    const sessionDecision = this.sessionDecisions.get(sessionKey);
+    if (sessionDecision !== void 0) {
+      return { allowed: sessionDecision, reason: "session decision" };
+    }
+    return { allowed: false, reason: "No rule matched \u2014 requires user approval" };
+  }
+  /**
+   * Record a user decision for the session.
+   */
+  recordDecision(toolName, content, allowed) {
+    const key = `${toolName}:${content}`;
+    this.sessionDecisions.set(key, allowed);
+  }
+  /**
+   * Add a permission rule.
+   */
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  /**
+   * Set the permission mode.
+   */
+  setMode(mode) {
+    this.mode = mode;
+  }
+  /**
+   * Get the current permission mode.
+   */
+  getMode() {
+    return this.mode;
+  }
+  matchTool(toolName, pattern) {
+    if (pattern === "*") return true;
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    return regex.test(toolName);
+  }
+  matchContent(content, pattern) {
+    if (pattern.endsWith("*")) {
+      return content.startsWith(pattern.slice(0, -1).trim());
+    }
+    return content.includes(pattern);
+  }
+};
+
+// src/safety/command-inspector.ts
+var SAFE_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "dir",
+  "cat",
+  "type",
+  "head",
+  "tail",
+  "less",
+  "more",
+  "pwd",
+  "echo",
+  "whoami",
+  "hostname",
+  "date",
+  "uname",
+  "git status",
+  "git log",
+  "git diff",
+  "git branch",
+  "git show",
+  "git remote",
+  "node --version",
+  "npm --version",
+  "npx --version",
+  "which",
+  "where",
+  "env",
+  "printenv",
+  "grep",
+  "find",
+  "wc",
+  "sort",
+  "uniq",
+  "diff",
+  "ps",
+  "top",
+  "df",
+  "du",
+  "free",
+  "curl --head",
+  "curl -I"
+]);
+var DANGEROUS_PATTERNS = [
+  /\brm\s+(-rf?|-fr?)\s+\//,
+  /\brm\s+(-rf?|-fr?)\s+\*/,
+  /\bdd\s+if=/,
+  /\bmkfs\./,
+  /\b(format\s+[A-Z]:)/i,
+  />\s*\/dev\//,
+  /\bshutdown\b/,
+  /\breboot\b/,
+  /\binit\s+[06]\b/,
+  /\bsudo\s+rm\b/,
+  /\bchmod\s+(-R\s+)?000\b/,
+  /\bchown\s+(-R\s+)?root\b/
+];
+var FILE_MODIFYING_COMMANDS = /* @__PURE__ */ new Set([
+  "touch",
+  "mkdir",
+  "cp",
+  "mv",
+  "rm",
+  "rmdir",
+  "chmod",
+  "chown",
+  "ln",
+  "npm install",
+  "npm uninstall",
+  "npm update",
+  "pip install",
+  "pip uninstall",
+  "git add",
+  "git commit",
+  "git push",
+  "git merge",
+  "git rebase",
+  "git reset",
+  "git checkout",
+  "docker",
+  "kubectl"
+]);
+var NETWORK_COMMANDS = /* @__PURE__ */ new Set([
+  "curl",
+  "wget",
+  "ssh",
+  "scp",
+  "rsync",
+  "nc",
+  "netcat",
+  "ping",
+  "traceroute",
+  "dig",
+  "nslookup",
+  "npm publish",
+  "git push",
+  "git fetch",
+  "git pull"
+]);
+function inspectCommand(command) {
+  const trimmed = command.trim();
+  const baseCommand = trimmed.split(/\s+/)[0] ?? "";
+  const fullCommand = trimmed.toLowerCase();
+  for (const pattern of DANGEROUS_PATTERNS) {
+    if (pattern.test(fullCommand)) {
+      return {
+        risk: "dangerous",
+        reason: "Potentially destructive command detected",
+        baseCommand,
+        modifiesFiles: true,
+        accessesNetwork: false
+      };
+    }
+  }
+  const pipeParts = trimmed.split(/\|/).map((p) => p.trim());
+  let maxRisk = "safe";
+  let modifiesFiles = false;
+  let accessesNetwork = false;
+  for (const part of pipeParts) {
+    const analysis = analyzeSingleCommand(part);
+    if (analysis.risk === "dangerous") return analysis;
+    if (analysis.risk === "moderate") maxRisk = "moderate";
+    if (analysis.modifiesFiles) modifiesFiles = true;
+    if (analysis.accessesNetwork) accessesNetwork = true;
+  }
+  return {
+    risk: maxRisk,
+    reason: maxRisk === "safe" ? "Readonly or low-risk command" : "Command may modify files or access network",
+    baseCommand,
+    modifiesFiles,
+    accessesNetwork
+  };
+}
+function analyzeSingleCommand(command) {
+  const trimmed = command.trim();
+  const parts = trimmed.split(/\s+/);
+  const base = parts[0] ?? "";
+  const fullCommand = trimmed.toLowerCase();
+  const firstTwoWords = parts.slice(0, 2).join(" ").toLowerCase();
+  if (SAFE_COMMANDS.has(fullCommand) || SAFE_COMMANDS.has(firstTwoWords)) {
+    return {
+      risk: "safe",
+      reason: "Known safe command",
+      baseCommand: base,
+      modifiesFiles: false,
+      accessesNetwork: false
+    };
+  }
+  const modifiesFiles = matchesAny(fullCommand, firstTwoWords, FILE_MODIFYING_COMMANDS);
+  const accessesNetwork = matchesAny(fullCommand, firstTwoWords, NETWORK_COMMANDS);
+  let risk = "safe";
+  if (modifiesFiles || accessesNetwork) risk = "moderate";
+  return {
+    risk,
+    reason: risk === "safe" ? "Low-risk command" : modifiesFiles ? "Modifies filesystem" : "Accesses network",
+    baseCommand: base,
+    modifiesFiles,
+    accessesNetwork
+  };
+}
+function matchesAny(fullCommand, firstTwoWords, set) {
+  return set.has(fullCommand) || set.has(firstTwoWords) || Array.from(set).some((cmd) => fullCommand.startsWith(cmd));
+}
+
+// src/services/history.ts
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { dirname } from "path";
+var DEFAULT_CONFIG2 = {
+  maxEntries: 1e3,
+  filePath: getHistoryPath()
+};
+var HistoryManager = class {
+  entries = [];
+  config;
+  cursorIndex = -1;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  addEntry(content, type = "user") {
+    const trimmed = content.trim();
+    if (!trimmed) return;
+    const lastEntry = this.entries[this.entries.length - 1];
+    if (lastEntry && lastEntry.content === trimmed) return;
+    this.entries.push({
+      content: trimmed,
+      timestamp: Date.now(),
+      type
+    });
+    if (this.entries.length > this.config.maxEntries) {
+      this.entries = this.entries.slice(-this.config.maxEntries);
+    }
+    this.cursorIndex = this.entries.length;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.entries.filter((e) => e.content.toLowerCase().includes(lowerQuery));
+  }
+  getRecent(count) {
+    return this.entries.slice(-count);
+  }
+  clear() {
+    this.entries = [];
+    this.cursorIndex = -1;
+  }
+  navigateUp() {
+    if (this.entries.length === 0) return null;
+    if (this.cursorIndex > 0) {
+      this.cursorIndex--;
+    } else if (this.cursorIndex === -1 || this.cursorIndex === this.entries.length) {
+      this.cursorIndex = this.entries.length - 1;
+    }
+    return this.entries[this.cursorIndex]?.content ?? null;
+  }
+  navigateDown() {
+    if (this.cursorIndex < this.entries.length - 1) {
+      this.cursorIndex++;
+      return this.entries[this.cursorIndex]?.content ?? null;
+    }
+    this.cursorIndex = this.entries.length;
+    return null;
+  }
+  async save() {
+    const filePath = this.resolvePath();
+    const dir = dirname(filePath);
+    if (!existsSync3(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+    const lines = this.entries.map((e) => JSON.stringify(e)).join("\n");
+    await writeFile2(filePath, lines, "utf-8");
+  }
+  async load() {
+    const filePath = this.resolvePath();
+    if (!existsSync3(filePath)) {
+      this.entries = [];
+      this.cursorIndex = -1;
+      return;
+    }
+    const content = await readFile3(filePath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    const loaded = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.content && typeof entry.content === "string" && entry.timestamp) {
+          loaded.push({
+            content: entry.content,
+            timestamp: entry.timestamp,
+            type: entry.type ?? "user"
+          });
+        }
+      } catch {
+      }
+    }
+    this.entries = loaded.slice(-this.config.maxEntries);
+    this.cursorIndex = this.entries.length;
+  }
+  resolvePath() {
+    if (this.config.filePath.startsWith("~")) {
+      return getHistoryPath();
+    }
+    return this.config.filePath;
+  }
+};
+
+// src/hooks/registry.ts
+var HookRegistry = class {
+  hooks = /* @__PURE__ */ new Map();
+  register(hook) {
+    this.hooks.set(hook.id, hook);
+  }
+  unregister(id) {
+    this.hooks.delete(id);
+  }
+  getHooksForEvent(event) {
+    return Array.from(this.hooks.values()).filter(
+      (h) => h.event === event && h.enabled
+    );
+  }
+  getAll() {
+    return Array.from(this.hooks.values());
+  }
+  loadFromConfig(config) {
+    if (!config || typeof config !== "object") return;
+    const cfg = config;
+    const hooksArr = cfg.hooks;
+    if (!Array.isArray(hooksArr)) return;
+    for (const raw of hooksArr) {
+      if (!raw || typeof raw !== "object") continue;
+      const def = raw;
+      const hook = {
+        id: String(def.id ?? `hook_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`),
+        event: String(def.event ?? "pre_tool_use"),
+        type: def.type === "function" ? "function" : "command",
+        command: typeof def.command === "string" ? def.command : void 0,
+        handler: typeof def.handler === "string" ? def.handler : void 0,
+        condition: def.condition && typeof def.condition === "object" ? def.condition : void 0,
+        timeout: typeof def.timeout === "number" ? def.timeout : 3e4,
+        enabled: def.enabled !== false
+      };
+      this.register(hook);
+    }
+  }
+  clear() {
+    this.hooks.clear();
+  }
+};
+
+// src/hooks/executor.ts
+import { exec } from "child_process";
+var HookExecutor = class {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async executeHooks(event, context) {
+    const hooks = this.registry.getHooksForEvent(event);
+    const matched = hooks.filter((h) => this.matchesCondition(h, context));
+    const results = [];
+    for (const hook of matched) {
+      const result = await this.executeOne(hook, context);
+      results.push(result);
+    }
+    return results;
+  }
+  matchesCondition(hook, context) {
+    if (!hook.condition) return true;
+    if (hook.condition.tool_name && context.toolName) {
+      if (hook.condition.tool_name !== context.toolName) return false;
+    }
+    if (hook.condition.pattern) {
+      try {
+        const regex = new RegExp(hook.condition.pattern);
+        const text = context.toolOutput ?? String(context.toolInput ?? "");
+        if (!regex.test(text)) return false;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  executeOne(hook, context) {
+    const start = Date.now();
+    if (hook.type === "function") {
+      return Promise.resolve({
+        hookId: hook.id,
+        success: true,
+        output: `Function handler "${hook.handler}" executed (stub)`,
+        duration: Date.now() - start
+      });
+    }
+    return this.executeCommand(hook, context, start);
+  }
+  executeCommand(hook, context, start) {
+    const command = hook.command ?? "";
+    const env = {
+      ...process.env,
+      CLISKILL_EVENT: context.event,
+      CLISKILL_TOOL_NAME: context.toolName ?? "",
+      CLISKILL_WORKING_DIR: context.workingDirectory
+    };
+    if (context.error) {
+      env.CLISKILL_ERROR_MESSAGE = context.error.message;
+    }
+    return new Promise((resolve2) => {
+      exec(
+        command,
+        {
+          timeout: hook.timeout,
+          cwd: context.workingDirectory,
+          env
+        },
+        (error, stdout, stderr) => {
+          const duration = Date.now() - start;
+          if (error) {
+            resolve2({
+              hookId: hook.id,
+              success: false,
+              output: stdout?.trim() ?? "",
+              error: stderr?.trim() || error.message,
+              duration
+            });
+          } else {
+            resolve2({
+              hookId: hook.id,
+              success: true,
+              output: stdout?.trim() ?? "",
+              duration
+            });
+          }
+        }
+      );
+    });
+  }
+};
+
+// src/utils/bash-parser.ts
+var SAFE_COMMANDS2 = /* @__PURE__ */ new Set([
+  "ls",
+  "cat",
+  "pwd",
+  "echo",
+  "head",
+  "tail",
+  "grep",
+  "find",
+  "wc",
+  "sort",
+  "uniq",
+  "date",
+  "whoami",
+  "hostname",
+  "uname",
+  "which",
+  "type",
+  "file",
+  "stat",
+  "df",
+  "du",
+  "ps",
+  "top",
+  "env",
+  "printenv",
+  "id",
+  "dirname",
+  "basename",
+  "realpath"
+]);
+var MODERATE_COMMANDS = /* @__PURE__ */ new Set([
+  "curl",
+  "wget",
+  "npm",
+  "pip",
+  "git",
+  "make",
+  "docker",
+  "node",
+  "python",
+  "python3",
+  "java",
+  "go",
+  "cargo",
+  "apt",
+  "yum",
+  "brew",
+  "npx",
+  "yarn",
+  "pnpm"
+]);
+var DANGEROUS_COMMANDS = /* @__PURE__ */ new Set([
+  "rm",
+  "mv",
+  "chmod",
+  "chown",
+  "sudo",
+  "su",
+  "dd",
+  "mkfs",
+  "format",
+  "fdisk",
+  "mkfs.ext4",
+  "mkfs.ntfs",
+  "shutdown",
+  "reboot",
+  "halt",
+  "poweroff",
+  "kill",
+  "killall"
+]);
+var REDIRECTION_RE = /\s(&?>{1,2}|2>>?|<{1,2})\s*(\S+)/g;
+var ENV_VAR_RE = /^([A-Za-z_][A-Za-z0-9_]*)=(\S*)\s+/;
+var SUBSHELL_RE = /\$\(([^)]+)\)/;
+var OPERATOR_SPLIT_RE = /\s*(\|\||&&|;|\|)\s*/;
+function parseCommand(input) {
+  const trimmed = input.trim();
+  let remaining = trimmed;
+  const envVars = {};
+  let envMatch;
+  while ((envMatch = ENV_VAR_RE.exec(remaining)) !== null) {
+    envVars[envMatch[1]] = envMatch[2];
+    remaining = remaining.slice(envMatch[0].length);
+  }
+  const isBackground = /(?:^|\s)&\s*$/.test(remaining);
+  if (isBackground) {
+    remaining = remaining.replace(/&\s*$/, "").trim();
+  }
+  const redirections = [];
+  let redirMatch;
+  while ((redirMatch = REDIRECTION_RE.exec(remaining)) !== null) {
+    const kind = redirMatch[1];
+    const target = redirMatch[2];
+    if (kind === "|") {
+      redirections.push({ type: "|", target });
+    } else if (kind === ">>") {
+      redirections.push({ type: ">>", target });
+    } else if (kind === "2>>") {
+      redirections.push({ type: "2>>", target });
+    } else if (kind === "2>") {
+      redirections.push({ type: "2>", target });
+    } else if (kind === "&>") {
+      redirections.push({ type: "&>", target });
+    } else if (kind === "<" || kind === "<<") {
+      redirections.push({ type: "<", target });
+    } else {
+      redirections.push({ type: ">", target });
+    }
+  }
+  remaining = remaining.replace(REDIRECTION_RE, " ").trim();
+  const isSubshell = SUBSHELL_RE.test(remaining);
+  const subCommands = [];
+  let subMatch;
+  const subshellGlobal = /\$\(([^)]+)\)/g;
+  while ((subMatch = subshellGlobal.exec(remaining)) !== null) {
+    subCommands.push(parseCommand(subMatch[1]));
+  }
+  const parts = remaining.split(OPERATOR_SPLIT_RE).filter(Boolean);
+  const operators = [];
+  const commandParts = [];
+  for (const part of parts) {
+    if (["||", "&&", ";", "|"].includes(part)) {
+      operators.push(part);
+    } else {
+      commandParts.push(part);
+    }
+  }
+  let command = "";
+  let args = [];
+  if (commandParts.length > 0) {
+    const first = commandParts[0];
+    const tokens = tokenize(first);
+    command = tokens[0] ?? "";
+    args = tokens.slice(1);
+  }
+  const parsedSubCommands = commandParts.slice(1).map((cp) => {
+    const tokens = tokenize(cp);
+    return {
+      command: tokens[0] ?? "",
+      args: tokens.slice(1),
+      operators: [],
+      subCommands: [],
+      redirections: [],
+      envVars: {},
+      isBackground: false,
+      isSubshell: false
+    };
+  });
+  return {
+    command,
+    args,
+    operators,
+    subCommands: [...subCommands, ...parsedSubCommands],
+    redirections,
+    envVars,
+    isBackground,
+    isSubshell
+  };
+}
+function analyzeCommand(input) {
+  const parsed = parseCommand(input);
+  const allCommands = collectCommands(parsed);
+  const isPipe = parsed.operators.includes("|");
+  const isChained = parsed.operators.some((op) => op === "&&" || op === "||" || op === ";");
+  const hasRedirection = parsed.redirections.length > 0;
+  const hasSubshell = parsed.isSubshell || parsed.subCommands.length > 0;
+  const envVarCount = Object.keys(parsed.envVars).length;
+  const estimatedRisk = determineRisk(allCommands, isPipe, isChained, hasRedirection, hasSubshell);
+  return {
+    commands: allCommands,
+    isPipe,
+    isChained,
+    hasRedirection,
+    hasSubshell,
+    isBackground: parsed.isBackground,
+    envVarCount,
+    estimatedRisk
+  };
+}
+function collectCommands(parsed) {
+  const commands = [];
+  if (parsed.command) {
+    commands.push(parsed.command);
+  }
+  for (const sub of parsed.subCommands) {
+    commands.push(...collectCommands(sub));
+  }
+  return commands;
+}
+function determineRisk(commands, isPipe, isChained, hasRedirection, hasSubshell) {
+  let hasDangerous = false;
+  let hasModerate = false;
+  for (const cmd of commands) {
+    const base = cmd.split("/").pop() ?? cmd;
+    if (DANGEROUS_COMMANDS.has(base)) hasDangerous = true;
+    else if (MODERATE_COMMANDS.has(base)) hasModerate = true;
+  }
+  if (hasDangerous) return "dangerous";
+  if (hasModerate) return "moderate";
+  const allSafe = commands.every((cmd) => {
+    const base = cmd.split("/").pop() ?? cmd;
+    return SAFE_COMMANDS2.has(base);
+  });
+  if (allSafe && commands.length > 0) return "safe";
+  if (isPipe || isChained || hasRedirection || hasSubshell) {
+    return "moderate";
+  }
+  return "moderate";
+}
+function tokenize(segment) {
+  const tokens = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < segment.length; i++) {
+    const ch = segment[i];
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (ch === "\\" && !inSingle && i + 1 < segment.length) {
+      current += segment[i + 1];
+      i++;
+      continue;
+    }
+    if (/\s/.test(ch) && !inSingle && !inDouble) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+var REQUEST_TIMEOUT = 3e4;
+var MCPClient = class {
+  config;
+  process = null;
+  rl = null;
+  connected = false;
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  buffer = "";
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    if (this.connected) return;
+    const env = {
+      ...process.env,
+      ...this.config.env
+    };
+    this.process = spawn(this.config.command, this.config.args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    this.process.on("error", (err) => {
+      this.cleanup();
+      throw err;
+    });
+    this.process.on("exit", () => {
+      this.cleanup();
+    });
+    if (!this.process.stdout) {
+      throw new Error("MCP server stdout is not available");
+    }
+    this.rl = createInterface({ input: this.process.stdout });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    if (this.process.stderr) {
+      this.process.stderr.on("data", () => {
+      });
+    }
+    await this.sendRequest("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "cliskill", version: "1.0.0" }
+    });
+    this.sendNotification("notifications/initialized", {});
+    this.connected = true;
+  }
+  async disconnect() {
+    if (!this.process) return;
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+    this.process.kill("SIGTERM");
+    this.cleanup();
+  }
+  async listTools() {
+    const response = await this.sendRequest("tools/list", {});
+    const result = response.result;
+    return result?.tools ?? [];
+  }
+  async callTool(name, args) {
+    const response = await this.sendRequest("tools/call", { name, arguments: args });
+    return response.result;
+  }
+  async listResources() {
+    const response = await this.sendRequest("resources/list", {});
+    const result = response.result;
+    return result?.resources ?? [];
+  }
+  async readResource(uri) {
+    const response = await this.sendRequest("resources/read", { uri });
+    return response.result;
+  }
+  async listPrompts() {
+    const response = await this.sendRequest("prompts/list", {});
+    const result = response.result;
+    return result?.prompts ?? [];
+  }
+  isConnected() {
+    return this.connected;
+  }
+  sendRequest(method, params) {
+    return new Promise((resolve2, reject) => {
+      if (!this.process?.stdin) {
+        reject(new Error("MCP server not connected"));
+        return;
+      }
+      const id = this.nextId++;
+      const request = { jsonrpc: "2.0", id, method, params };
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method} (id=${id})`));
+      }, REQUEST_TIMEOUT);
+      this.pendingRequests.set(id, { resolve: resolve2, reject, timer });
+      const data = JSON.stringify(request) + "\n";
+      this.process.stdin.write(data, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          this.pendingRequests.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+  sendNotification(method, params) {
+    if (!this.process?.stdin) return;
+    const notification = { jsonrpc: "2.0", method, params };
+    const data = JSON.stringify(notification) + "\n";
+    this.process.stdin.write(data);
+  }
+  handleLine(line) {
+    this.buffer += line;
+    let response;
+    try {
+      response = JSON.parse(this.buffer);
+    } catch {
+      return;
+    } finally {
+      this.buffer = "";
+    }
+    if (response.id !== void 0 && response.id !== null) {
+      const pending = this.pendingRequests.get(response.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(response.id);
+        pending.resolve(response);
+      }
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.rl?.close();
+    this.rl = null;
+    this.process = null;
+    this.buffer = "";
+  }
+};
+
+// src/mcp/manager.ts
+var MCPConnectionManager = class {
+  clients = /* @__PURE__ */ new Map();
+  async addServer(config) {
+    const client = new MCPClient(config);
+    await client.connect();
+    this.clients.set(config.name, client);
+  }
+  async removeServer(name) {
+    const client = this.clients.get(name);
+    if (client) {
+      await client.disconnect();
+      this.clients.delete(name);
+    }
+  }
+  getConnectedServers() {
+    return Array.from(this.clients.entries()).filter(([, client]) => client.isConnected()).map(([name]) => name);
+  }
+  async getAllTools() {
+    const allTools = [];
+    for (const [, client] of this.clients) {
+      if (!client.isConnected()) continue;
+      try {
+        const tools = await client.listTools();
+        allTools.push(...tools);
+      } catch {
+      }
+    }
+    return allTools;
+  }
+  async callTool(serverName, toolName, args) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      throw new Error(`MCP server "${serverName}" not found`);
+    }
+    if (!client.isConnected()) {
+      throw new Error(`MCP server "${serverName}" is not connected`);
+    }
+    return client.callTool(toolName, args);
+  }
+  async getToolsForServer(serverName) {
+    const client = this.clients.get(serverName);
+    if (!client || !client.isConnected()) {
+      return [];
+    }
+    return client.listTools();
+  }
+  async disconnectAll() {
+    for (const [, client] of this.clients) {
+      try {
+        await client.disconnect();
+      } catch {
+      }
+    }
+    this.clients.clear();
+  }
+};
+
+// src/tasks/manager.ts
+var TaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  idCounter = 0;
+  createTask(definition) {
+    const id = `task_${++this.idCounter}_${Date.now()}`;
+    const task = {
+      ...definition,
+      id,
+      status: "pending",
+      createdAt: Date.now(),
+      progress: 0
+    };
+    this.tasks.set(id, task);
+    return id;
+  }
+  cancelTask(id) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    if (task.status !== "running" && task.status !== "pending") return;
+    task.status = "cancelled";
+    task.completedAt = Date.now();
+    this.emit("onStatusChange", id, "cancelled");
+  }
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  listTasks(filter) {
+    const all = Array.from(this.tasks.values());
+    if (!filter?.status) return all;
+    return all.filter((t) => t.status === filter.status);
+  }
+  getActiveCount() {
+    let count = 0;
+    for (const task of this.tasks.values()) {
+      if (task.status === "running" || task.status === "pending") count++;
+    }
+    return count;
+  }
+  removeTask(id) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    if (task.status === "running") {
+      throw new Error(`Cannot remove running task "${id}". Cancel it first.`);
+    }
+    this.tasks.delete(id);
+  }
+  clearCompleted() {
+    for (const [id, task] of this.tasks) {
+      if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") {
+        this.tasks.delete(id);
+      }
+    }
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  /** @internal Update task status */
+  updateStatus(id, status) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.status = status;
+    if (status === "running") task.startedAt = Date.now();
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      task.completedAt = Date.now();
+    }
+    this.emit("onStatusChange", id, status);
+  }
+  /** @internal Update task progress */
+  updateProgress(id, progress, message) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.progress = Math.min(100, Math.max(0, progress));
+    this.emit("onProgress", id, task.progress, message);
+  }
+  /** @internal Set task result */
+  setResult(id, result) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.result = result;
+    task.status = "completed";
+    task.completedAt = Date.now();
+    task.progress = 100;
+    this.emit("onComplete", id, result);
+    this.emit("onStatusChange", id, "completed");
+  }
+  /** @internal Set task error */
+  setError(id, error) {
+    const task = this.tasks.get(id);
+    if (!task) return;
+    task.error = error;
+    task.status = "failed";
+    task.completedAt = Date.now();
+    this.emit("onError", id, error);
+    this.emit("onStatusChange", id, "failed");
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((fn) => fn(...args));
+  }
+};
+
+// src/tasks/executor.ts
+import { exec as exec2 } from "child_process";
+async function executeAgentTask(taskId, manager, adapter, tools, prompt, signal) {
+  manager.updateStatus(taskId, "running");
+  const engine = new QueryEngine(
+    { maxTurns: 20, systemPrompt: "You are a background agent. Complete the task concisely." },
+    adapter,
+    tools
+  );
+  let finalText = "";
+  let turnsUsed = 0;
+  try {
+    for await (const event of engine.run(prompt)) {
+      if (signal?.aborted) {
+        manager.cancelTask(taskId);
+        return;
+      }
+      switch (event.type) {
+        case "text_delta":
+          finalText += event.text;
+          break;
+        case "turn_end":
+          turnsUsed = event.turn;
+          manager.updateProgress(taskId, Math.min(90, turnsUsed * 10));
+          break;
+        case "complete":
+          finalText = finalText || event.result.messages.filter((m) => m.role === "assistant").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("\n") || "Task completed";
+          break;
+        case "error":
+          manager.setError(taskId, event.error.message);
+          return;
+      }
+    }
+    manager.setResult(taskId, finalText || "Task completed (no output)");
+  } catch (err) {
+    manager.setError(taskId, err.message);
+  }
+}
+async function executeShellTask(taskId, manager, command, cwd, signal) {
+  manager.updateStatus(taskId, "running");
+  return new Promise((resolve2) => {
+    const child = exec2(command, { cwd, signal }, (error, stdout, stderr) => {
+      if (signal?.aborted) {
+        manager.cancelTask(taskId);
+        resolve2();
+        return;
+      }
+      if (error) {
+        manager.setError(taskId, stderr || error.message);
+        resolve2();
+        return;
+      }
+      manager.setResult(taskId, stdout || "(no output)");
+      resolve2();
+    });
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        child.kill("SIGTERM");
+      }, { once: true });
+    }
+  });
+}
+
+// src/swarm/coordinator.ts
+var MAX_PARALLEL_WORKERS = 3;
+var SUBTASK_REGEX = /(?:^|\n)\s*(?:\d+[\.\)])\s*(.+?)(?=\n\s*(?:\d+[\.\)])|$)/gs;
+var SwarmCoordinator = class {
+  constructor(adapter, tools) {
+    this.adapter = adapter;
+    this.tools = tools;
+  }
+  adapter;
+  tools;
+  agents = /* @__PURE__ */ new Map();
+  mailbox = /* @__PURE__ */ new Map();
+  abortController = new AbortController();
+  addAgent(config) {
+    this.agents.set(config.id, config);
+    this.mailbox.set(config.id, []);
+  }
+  removeAgent(id) {
+    this.agents.delete(id);
+    this.mailbox.delete(id);
+  }
+  getAgents() {
+    return Array.from(this.agents.values());
+  }
+  async sendMessage(message) {
+    if (message.to === "*") {
+      for (const [agentId] of this.agents) {
+        this.mailbox.get(agentId)?.push({ ...message, to: agentId });
+      }
+    } else {
+      this.mailbox.get(message.to)?.push(message);
+    }
+  }
+  async executeSwarm(task) {
+    this.abortController = new AbortController();
+    const startTime = performance.now();
+    const coordinator = this.findAgentByRole("coordinator");
+    const workers = this.findAgentsByRole("worker");
+    const reviewers = this.findAgentsByRole("reviewer");
+    const subtasks = coordinator ? await this.decomposeTask(coordinator, task) : this.fallbackDecompose(task, workers.length);
+    const assignments = this.assignSubtasks(subtasks, workers);
+    const workerResults = await this.executeParallel(assignments);
+    if (reviewers.length > 0) {
+      await this.reviewResults(reviewers[0], workerResults);
+    }
+    const results = workerResults.map((wr) => ({
+      agentId: wr.agentId,
+      agentName: wr.agentName,
+      task: wr.task,
+      result: wr.result,
+      success: wr.success,
+      duration: performance.now() - startTime,
+      turns: wr.turns
+    }));
+    return results;
+  }
+  shutdown() {
+    this.abortController.abort();
+    for (const [agentId] of this.agents) {
+      this.mailbox.get(agentId)?.push({
+        from: "system",
+        to: agentId,
+        type: "shutdown",
+        content: "Shutdown requested",
+        timestamp: Date.now()
+      });
+    }
+  }
+  findAgentByRole(role) {
+    for (const agent of this.agents.values()) {
+      if (agent.role === role) return agent;
+    }
+    return void 0;
+  }
+  findAgentsByRole(role) {
+    return Array.from(this.agents.values()).filter((a) => a.role === role);
+  }
+  async decomposeTask(coordinator, task) {
+    const engine = this.createEngine(coordinator);
+    const prompt = `Decompose the following task into subtasks. Return ONLY a numbered list, one subtask per line. No explanations.
+
+Task: ${task}
+
+Subtasks:`;
+    let decomposition = "";
+    try {
+      for await (const event of engine.run(prompt)) {
+        if (event.type === "text_delta") decomposition += event.text;
+        if (event.type === "error") break;
+      }
+    } catch {
+      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
+    }
+    const matches = [...decomposition.matchAll(SUBTASK_REGEX)];
+    if (matches.length === 0) {
+      return this.fallbackDecompose(task, this.findAgentsByRole("worker").length);
+    }
+    return matches.map((m, i) => ({
+      id: `subtask_${i + 1}`,
+      description: m[1].trim(),
+      status: "pending"
+    }));
+  }
+  fallbackDecompose(task, workerCount) {
+    const count = Math.max(1, Math.min(workerCount, MAX_PARALLEL_WORKERS));
+    return Array.from({ length: count }, (_, i) => ({
+      id: `subtask_${i + 1}`,
+      description: count === 1 ? task : `Part ${i + 1} of: ${task}`,
+      status: "pending"
+    }));
+  }
+  assignSubtasks(subtasks, workers) {
+    const assignments = [];
+    if (workers.length === 0) return assignments;
+    subtasks.forEach((task, i) => {
+      const worker = workers[i % workers.length];
+      task.assignedTo = worker.id;
+      assignments.push({ task, worker });
+    });
+    return assignments;
+  }
+  async executeParallel(assignments) {
+    const chunks = [];
+    for (let i = 0; i < assignments.length; i += MAX_PARALLEL_WORKERS) {
+      chunks.push(assignments.slice(i, i + MAX_PARALLEL_WORKERS));
+    }
+    const allResults = [];
+    for (const chunk of chunks) {
+      if (this.abortController.signal.aborted) break;
+      const settled = await Promise.allSettled(
+        chunk.map(async ({ task, worker }) => {
+          task.status = "running";
+          const engine = this.createEngine(worker);
+          let output = "";
+          let turns = 0;
+          try {
+            for await (const event of engine.run(task.description)) {
+              if (this.abortController.signal.aborted) break;
+              if (event.type === "text_delta") output += event.text;
+              if (event.type === "turn_end") turns = event.turn;
+              if (event.type === "complete") {
+                turns = event.result.turns;
+                output = output || event.result.messages.filter((m) => m.role === "assistant").flatMap((m) => m.content).filter((b) => b.type === "text").map((b) => b.text).join("\n");
+              }
+            }
+            task.status = "completed";
+            task.result = output;
+            return { agentId: worker.id, agentName: worker.name, task: task.description, result: output, success: true, turns };
+          } catch (err) {
+            task.status = "failed";
+            return { agentId: worker.id, agentName: worker.name, task: task.description, result: err.message, success: false, turns };
+          }
+        })
+      );
+      for (const r of settled) {
+        if (r.status === "fulfilled") allResults.push(r.value);
+        else allResults.push({ agentId: "unknown", agentName: "unknown", task: "", result: r.reason?.message ?? "Unknown error", success: false, turns: 0 });
+      }
+    }
+    return allResults;
+  }
+  async reviewResults(reviewer, results) {
+    const engine = this.createEngine(reviewer);
+    const summary = results.map((r, i) => `Worker ${i + 1} (${r.agentName}): ${r.success ? "SUCCESS" : "FAILED"}
+Task: ${r.task}
+Result: ${r.result.slice(0, 500)}`).join("\n\n");
+    const prompt = `Review the following worker results and provide a brief assessment:
+
+${summary}
+
+Provide a concise review:`;
+    try {
+      for await (const event of engine.run(prompt)) {
+        if (event.type === "error") break;
+      }
+    } catch {
+    }
+  }
+  createEngine(agent) {
+    const filteredTools = new ToolRegistry();
+    if (agent.tools) {
+      for (const toolName of agent.tools) {
+        const tool = this.tools.get(toolName);
+        if (tool) filteredTools.register(tool);
+      }
+    } else {
+      for (const tool of this.tools.getAll()) {
+        if (tool.name !== "agent") filteredTools.register(tool);
+      }
+    }
+    return new QueryEngine(
+      {
+        maxTurns: agent.maxTurns ?? 10,
+        systemPrompt: agent.systemPrompt ?? `You are agent "${agent.name}" with role "${agent.role}". Complete assigned tasks concisely.`
+      },
+      this.adapter,
+      filteredTools
+    );
+  }
+};
+export {
+  AdapterRegistry,
+  AgentTool,
+  ContextCompactor,
+  CostTracker,
+  EnhancedMemoryStore,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  GenericCompatAdapter,
+  HistoryManager,
+  HookExecutor,
+  HookRegistry,
+  InkApp,
+  LspTool,
+  MCPClient,
+  MCPConnectionManager,
+  MemoryStore,
+  MessageList,
+  PermissionManager,
+  QueryEngine,
+  SkillRegistry,
+  Spinner,
+  StatusBar,
+  StreamingToolExecutor,
+  SwarmCoordinator,
+  TaskManager,
+  ToolRegistry,
+  WebSearchTool,
+  analyzeCommand,
+  analyzeTokenBudget,
+  createDefaultToolRegistry,
+  estimateMessagesTokens,
+  estimateTokens,
+  executeAgentTask,
+  executeShellTask,
+  formatAnsiMessage,
+  inspectCommand,
+  parseCommand,
+  renderInkApp,
+  runAgentLoop,
+  runCli
+};
+//# sourceMappingURL=index.js.map