@freesyntax/notch-cli 0.5.17 → 0.5.20

package/dist/chunk-UR4XL6OM.js

@@ -0,0 +1,104 @@
+// src/tools/task.ts
+import { z } from "zod";
+import chalk from "chalk";
+var tasks = [];
+var nextId = 1;
+var parameters = z.object({
+  action: z.enum(["create", "update", "list", "get"]).describe("Action: create (new task), update (change status/subject), list (show all), get (show one)"),
+  subject: z.string().optional().describe("Task title \u2014 for create action"),
+  description: z.string().optional().describe("Task details \u2014 for create action"),
+  task_id: z.number().int().positive().optional().describe("Task ID \u2014 for update/get actions"),
+  status: z.enum(["pending", "in_progress", "completed", "failed"]).optional().describe("New status \u2014 for update action")
+});
+function formatTask(t) {
+  const icons = {
+    pending: "\u25CB",
+    in_progress: "\u25D0",
+    completed: "\u25CF",
+    failed: "\u2717"
+  };
+  const colors = {
+    pending: chalk.gray,
+    in_progress: chalk.yellow,
+    completed: chalk.green,
+    failed: chalk.red
+  };
+  return `${colors[t.status](icons[t.status])} #${t.id} ${colors[t.status](t.subject)} [${t.status}]`;
+}
+function formatTaskList() {
+  if (tasks.length === 0) return "No tasks.";
+  return tasks.map(formatTask).join("\n");
+}
+var taskTool = {
+  name: "task",
+  description: "Manage tasks within the current session. Use this to break complex work into tracked steps. Actions: create (new task), update (change status), list (show all tasks), get (show one task). Mark tasks as in_progress when starting and completed when done.",
+  parameters,
+  async execute(params, _ctx) {
+    switch (params.action) {
+      case "create": {
+        if (!params.subject) {
+          return { content: "subject is required for create action.", isError: true };
+        }
+        const task = {
+          id: nextId++,
+          subject: params.subject,
+          description: params.description,
+          status: "pending",
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        tasks.push(task);
+        console.log(chalk.gray(`  ${formatTask(task)}`));
+        return { content: `Task #${task.id} created: ${task.subject}` };
+      }
+      case "update": {
+        if (params.task_id === void 0) {
+          return { content: "task_id is required for update action.", isError: true };
+        }
+        const task = tasks.find((t) => t.id === params.task_id);
+        if (!task) {
+          return { content: `Task #${params.task_id} not found.`, isError: true };
+        }
+        if (params.status) task.status = params.status;
+        if (params.subject) task.subject = params.subject;
+        task.updatedAt = Date.now();
+        console.log(chalk.gray(`  ${formatTask(task)}`));
+        return { content: `Task #${task.id} updated: ${task.subject} [${task.status}]` };
+      }
+      case "list": {
+        const output = formatTaskList();
+        return { content: output };
+      }
+      case "get": {
+        if (params.task_id === void 0) {
+          return { content: "task_id is required for get action.", isError: true };
+        }
+        const task = tasks.find((t) => t.id === params.task_id);
+        if (!task) {
+          return { content: `Task #${params.task_id} not found.`, isError: true };
+        }
+        const details = [
+          formatTask(task),
+          task.description ? `  ${task.description}` : "",
+          `  Created: ${new Date(task.createdAt).toLocaleTimeString()}`,
+          `  Updated: ${new Date(task.updatedAt).toLocaleTimeString()}`
+        ].filter(Boolean).join("\n");
+        return { content: details };
+      }
+      default:
+        return { content: `Unknown action: ${params.action}`, isError: true };
+    }
+  }
+};
+function getAllTasks() {
+  return [...tasks];
+}
+function formatTasksDisplay() {
+  return formatTaskList();
+}
+
+export {
+  taskTool,
+  getAllTasks,
+  formatTasksDisplay
+};

package/dist/chunk-W4FAGQFL.js

@@ -0,0 +1,171 @@
+// src/tools/shell.ts
+import { execFile, exec } from "child_process";
+import { promisify } from "util";
+import path from "path";
+import { z } from "zod";
+var execFileAsync = promisify(execFile);
+var execAsync = promisify(exec);
+var BLOCKED_PATTERNS = [
+  /rm\s+-rf\s+\/(?!\S)/,
+  // rm -rf /
+  /mkfs\./,
+  // format filesystem
+  /dd\s+if=.*of=\/dev/,
+  // raw disk write
+  /:\(\)\s*\{.*:\|:.*\}/,
+  // fork bomb
+  /chmod\s+-R\s+777\s+\//,
+  // recursive chmod on root
+  /curl\s.*\|\s*(?:ba)?sh/,
+  // curl | sh (remote code execution)
+  /wget\s.*\|\s*(?:ba)?sh/,
+  // wget | sh
+  />\s*\/dev\/sd[a-z]/,
+  // overwrite disk device
+  /shutdown|reboot|init\s+[06]/,
+  // system shutdown/reboot
+  /rm\s+-rf\s+~\//
+  // rm -rf ~/
+];
+var DESTRUCTIVE_PATTERNS = [
+  /rm\s+-rf/,
+  /rm\s+-r\s/,
+  /git\s+push\s+--force(?!\s+--with-lease)/,
+  /git\s+reset\s+--hard/,
+  /git\s+clean\s+-f/,
+  /git\s+checkout\s+--\s*\./,
+  /DROP\s+(TABLE|DATABASE)/i,
+  /TRUNCATE/i,
+  />\s*\/dev\/sd/,
+  /docker\s+(rm|rmi|system\s+prune)/,
+  /kubectl\s+delete/,
+  /npm\s+unpublish/
+];
+var BLOCKED_ENV_PATTERNS = [
+  /\bLD_PRELOAD=/,
+  /\bLD_LIBRARY_PATH=/,
+  /\bDYLD_INSERT_LIBRARIES=/,
+  /\bPATH=\//,
+  // Setting PATH to absolute (could shadow binaries)
+  /\bHOME=\//,
+  /\bSHELL=/
+];
+var MAX_OUTPUT = 5e4;
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_TIMEOUT = 6e5;
+var parameters = z.object({
+  command: z.string().describe("Shell command to execute"),
+  timeout: z.number().optional().describe("Timeout in ms (default 30s, max 10m)")
+});
+function validateCommand(command, cwd) {
+  for (const pattern of BLOCKED_PATTERNS) {
+    if (pattern.test(command)) {
+      return `Blocked: this command is too dangerous to execute.`;
+    }
+  }
+  for (const pattern of BLOCKED_ENV_PATTERNS) {
+    if (pattern.test(command)) {
+      return `Blocked: command attempts to override a protected environment variable.`;
+    }
+  }
+  const pipeSegments = command.split(/\s*\|\s*/);
+  for (const segment of pipeSegments) {
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(segment.trim())) {
+        return `Blocked: a pipe segment contains a dangerous command.`;
+      }
+    }
+  }
+  const subCommands = [
+    ...command.matchAll(/\$\(([^)]+)\)/g),
+    ...command.matchAll(/`([^`]+)`/g)
+  ];
+  for (const match2 of subCommands) {
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (pattern.test(match2[1])) {
+        return `Blocked: command substitution contains a dangerous command.`;
+      }
+    }
+  }
+  const fileOpRegex = /(?:^|\s)(?:>|>>|cat|cp|mv|ln|tee|tar|zip|scp|rsync|chmod|chown|rm)\s+(\/(?!tmp\b|dev\/null\b)[^\s]+)/g;
+  let match;
+  while ((match = fileOpRegex.exec(command)) !== null) {
+    const targetPath = path.normalize(match[1]);
+    if (!targetPath.startsWith(cwd) && !targetPath.startsWith("/tmp")) {
+      return `Blocked: command targets path outside project root: ${targetPath}`;
+    }
+  }
+  if (/(?:^|\s)(?:\.\.\/){3,}/.test(command)) {
+    return "Blocked: deep path traversal detected.";
+  }
+  return null;
+}
+function isDestructive(command) {
+  const segments = [command, ...command.split(/\s*\|\s*/)];
+  for (const segment of segments) {
+    for (const pattern of DESTRUCTIVE_PATTERNS) {
+      if (pattern.test(segment)) return true;
+    }
+  }
+  return false;
+}
+var shellTool = {
+  name: "shell",
+  description: "Execute a shell command in the project directory. Dangerous commands (rm -rf, DROP TABLE, git push --force) require confirmation. Some destructive system commands are blocked entirely.",
+  parameters,
+  async execute(params, ctx) {
+    const { command } = params;
+    const maxTimeout = ctx.shellTimeout ?? MAX_TIMEOUT;
+    const timeout = Math.min(params.timeout ?? DEFAULT_TIMEOUT, maxTimeout);
+    const validationError = validateCommand(command, ctx.cwd);
+    if (validationError) {
+      return { content: validationError, isError: true };
+    }
+    if (ctx.requireConfirm && isDestructive(command)) {
+      const confirmed = await ctx.confirm(
+        `\u26A0 Destructive command: ${command}
+Proceed?`
+      );
+      if (!confirmed) {
+        return { content: "Command cancelled by user.", isError: true };
+      }
+    }
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env, FORCE_COLOR: "0" }
+      });
+      const combined = [stdout, stderr].filter(Boolean).join("\n");
+      const trimmed = combined.length > MAX_OUTPUT ? combined.slice(0, MAX_OUTPUT) + `
+... (truncated, ${combined.length} chars total)` : combined;
+      return { content: trimmed || "(no output)" };
+    } catch (err) {
+      const e = err;
+      const stderr = e.stderr ?? "";
+      const stdout = e.stdout ?? "";
+      const combined = [stdout, stderr].filter(Boolean).join("\n");
+      const trimmed = combined.length > MAX_OUTPUT ? combined.slice(0, MAX_OUTPUT) + "\n... (truncated)" : combined;
+      if (e.killed && e.signal === "SIGTERM") {
+        return {
+          content: `Command timed out after ${(timeout / 1e3).toFixed(0)}s: ${command}
+
+Partial output:
+${trimmed || "(none)"}`,
+          isError: true
+        };
+      }
+      return {
+        content: `Command failed (exit ${e.status ?? e.code ?? "unknown"}):
+${trimmed || e.message || "Unknown error"}`,
+        isError: true
+      };
+    }
+  }
+};
+
+export {
+  shellTool
+};

package/dist/chunk-YAYPQTOU.js

@@ -0,0 +1,53 @@
+// src/tools/edit.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  path: z.string().describe("Relative or absolute path to the file"),
+  old_string: z.string().describe("Exact string to find and replace (must be unique in file)"),
+  new_string: z.string().describe("Replacement string"),
+  replace_all: z.boolean().optional().default(false).describe("Replace all occurrences")
+});
+var editTool = {
+  name: "edit",
+  description: "Perform exact string replacement in a file. old_string must match exactly and be unique unless replace_all is true. Use for surgical edits.",
+  parameters,
+  async execute(params, ctx) {
+    const filePath = path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path);
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      if (!content.includes(params.old_string)) {
+        return {
+          content: `old_string not found in ${filePath}. Make sure it matches exactly (including whitespace and indentation).`,
+          isError: true
+        };
+      }
+      if (!params.replace_all) {
+        const firstIdx = content.indexOf(params.old_string);
+        const secondIdx = content.indexOf(params.old_string, firstIdx + 1);
+        if (secondIdx !== -1) {
+          return {
+            content: `old_string appears multiple times in ${filePath}. Provide more surrounding context to make it unique, or set replace_all: true.`,
+            isError: true
+          };
+        }
+      }
+      const newContent = params.replace_all ? content.replaceAll(params.old_string, params.new_string) : content.replace(params.old_string, params.new_string);
+      await fs.writeFile(filePath, newContent, "utf-8");
+      const oldLines = params.old_string.split("\n").length;
+      const newLines = params.new_string.split("\n").length;
+      return {
+        content: `Edited ${filePath}: replaced ${oldLines} line(s) with ${newLines} line(s)`
+      };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { content: `File not found: ${filePath}`, isError: true };
+      }
+      return { content: `Error editing ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  editTool
+};