cliskill 1.0.4 → 1.0.6

package/dist/index.js

@@ -10,11 +10,14 @@ import {
   GenericCompatAdapter,
   InkApp,
   LspTool,
+  MCPClient,
+  MCPConnectionManager,
   MessageList,
   QueryEngine,
   Spinner,
   StatusBar,
   StreamingToolExecutor,
+  TaskManager,
   ToolRegistry,
   WebSearchTool,
   analyzeTokenBudget,
@@ -25,7 +28,7 @@ import {
   renderInkApp,
   runAgentLoop,
   runCli
-} from "./chunk-UJMUL64T.js";
+} from "./chunk-S4ZZPUPF.js";
 import {
   getGlobalSkillsDir,
   getHistoryPath
@@ -325,9 +328,31 @@ var PermissionManager = class {
   mode;
   rules = [];
   sessionDecisions = /* @__PURE__ */ new Map();
-  constructor(mode, rules) {
+  autoApprovePatterns = [];
+  decisionCache = /* @__PURE__ */ new Map();
+  cacheTtl = 6e4;
+  constructor(mode, rules, autoApprovePatterns) {
     this.mode = mode;
     this.rules = rules ?? [];
+    this.autoApprovePatterns = autoApprovePatterns ?? [];
+  }
+  /**
+   * P3.13: Dynamic permission check — evaluates tool + input together.
+   * Uses auto-approve patterns for regex-based matching.
+   */
+  canUseTool(toolName, input, riskLevel) {
+    const inputStr = JSON.stringify(input);
+    for (const pattern of this.autoApprovePatterns) {
+      if (this.matchTool(toolName, pattern.tool)) {
+        if (pattern.maxRiskLevel && this.riskLevelOrdinal(riskLevel) > this.riskLevelOrdinal(pattern.maxRiskLevel)) {
+          continue;
+        }
+        if (!pattern.inputPattern || pattern.inputPattern.test(inputStr)) {
+          return { allowed: true, reason: `Auto-approved by pattern: ${pattern.tool}` };
+        }
+      }
+    }
+    return this.check(toolName, riskLevel, inputStr);
   }
   /**
    * Check if a tool operation is allowed.
@@ -357,14 +382,22 @@ var PermissionManager = class {
     if (sessionDecision !== void 0) {
       return { allowed: sessionDecision, reason: "session decision" };
     }
+    const cached = this.decisionCache.get(sessionKey);
+    if (cached && Date.now() - cached.timestamp < this.cacheTtl) {
+      return cached.result;
+    }
     return { allowed: false, reason: "No rule matched \u2014 requires user approval" };
   }
   /**
-   * Record a user decision for the session.
+   * Record a user decision for the session with caching.
    */
   recordDecision(toolName, content, allowed) {
     const key = `${toolName}:${content}`;
     this.sessionDecisions.set(key, allowed);
+    this.decisionCache.set(key, {
+      result: { allowed, reason: "session decision" },
+      timestamp: Date.now()
+    });
   }
   /**
    * Add a permission rule.
@@ -372,6 +405,12 @@ var PermissionManager = class {
   addRule(rule) {
     this.rules.push(rule);
   }
+  /**
+   * P3.13: Add an auto-approve pattern.
+   */
+  addAutoApprovePattern(pattern) {
+    this.autoApprovePatterns.push(pattern);
+  }
   /**
    * Set the permission mode.
    */
@@ -395,6 +434,10 @@ var PermissionManager = class {
     }
     return content.includes(pattern);
   }
+  riskLevelOrdinal(level) {
+    const order = ["readonly", "safe", "destructive", "critical"];
+    return order.indexOf(level);
+  }
 };
 
 // src/safety/command-inspector.ts
@@ -1040,316 +1083,6 @@ function tokenize(segment) {
   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) {