@freesyntax/notch-cli 0.5.17 → 0.5.19

package/dist/chunk-C4CPDDMN.js

@@ -0,0 +1,246 @@
+// src/tools/apply-patch.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var PatchParseError = class extends Error {
+};
+var PatchApplyError = class extends Error {
+};
+function parsePatch(raw) {
+  const lines = raw.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "") i++;
+  if (i >= lines.length) throw new PatchParseError("Empty patch");
+  if (lines[i].trim() !== "*** Begin Patch") {
+    throw new PatchParseError(`Patch must start with "*** Begin Patch" (got: ${lines[i]})`);
+  }
+  i++;
+  const actions = [];
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "*** End Patch") {
+      i++;
+      return actions;
+    }
+    if (trimmed.startsWith("*** Add File: ")) {
+      const target = trimmed.slice("*** Add File: ".length).trim();
+      i++;
+      const body = [];
+      let sawPlusLine = false;
+      while (i < lines.length && !lines[i].startsWith("*** ")) {
+        const l = lines[i];
+        if (l.startsWith("+")) {
+          body.push(l.slice(1));
+          sawPlusLine = true;
+        } else if (l.trim() === "") body.push("");
+        else throw new PatchParseError(`Add File body line must start with '+': ${l}`);
+        i++;
+      }
+      const content = sawPlusLine ? body.join("\n") : "";
+      actions.push({ kind: "add", target, content });
+      continue;
+    }
+    if (trimmed.startsWith("*** Delete File: ")) {
+      const target = trimmed.slice("*** Delete File: ".length).trim();
+      actions.push({ kind: "delete", target });
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith("*** Update File: ")) {
+      const target = trimmed.slice("*** Update File: ".length).trim();
+      i++;
+      let moveTo;
+      if (i < lines.length && lines[i].trim().startsWith("*** Move to: ")) {
+        moveTo = lines[i].trim().slice("*** Move to: ".length).trim();
+        i++;
+      }
+      const hunks = [];
+      while (i < lines.length && !lines[i].startsWith("*** ")) {
+        const l = lines[i];
+        if (l.trim() === "*** End of File") {
+          i++;
+          continue;
+        }
+        if (l.startsWith("@@")) {
+          const header = l.slice(2).trim() || void 0;
+          i++;
+          const ops = [];
+          while (i < lines.length && !lines[i].startsWith("*** ") && !lines[i].startsWith("@@") && lines[i].trim() !== "*** End of File") {
+            ops.push(parseOp(lines[i]));
+            i++;
+          }
+          hunks.push({ header, ops });
+        } else {
+          const ops = [];
+          while (i < lines.length && !lines[i].startsWith("*** ") && !lines[i].startsWith("@@") && lines[i].trim() !== "*** End of File") {
+            ops.push(parseOp(lines[i]));
+            i++;
+          }
+          if (ops.length > 0) hunks.push({ ops });
+        }
+      }
+      if (hunks.length === 0) {
+        throw new PatchParseError(`Update File "${target}" has no hunks`);
+      }
+      actions.push({ kind: "update", target, moveTo, hunks });
+      continue;
+    }
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    throw new PatchParseError(`Unexpected patch line: ${line}`);
+  }
+  throw new PatchParseError('Patch missing "*** End Patch"');
+}
+function parseOp(line) {
+  if (line.startsWith("+")) return { op: "add", line: line.slice(1) };
+  if (line.startsWith("-")) return { op: "del", line: line.slice(1) };
+  if (line.startsWith(" ")) return { op: "keep", line: line.slice(1) };
+  if (line === "") return { op: "keep", line: "" };
+  throw new PatchParseError(`Hunk line must start with ' ', '+', or '-': ${line}`);
+}
+function applyHunk(source, hunk) {
+  const pattern = [];
+  const replacement = [];
+  for (const op of hunk.ops) {
+    if (op.op === "keep") {
+      pattern.push(op.line);
+      replacement.push(op.line);
+    } else if (op.op === "del") {
+      pattern.push(op.line);
+    } else if (op.op === "add") {
+      replacement.push(op.line);
+    }
+  }
+  if (pattern.length === 0) {
+    if (hunk.header) {
+      const idx = source.findIndex((l) => l.includes(hunk.header));
+      if (idx === -1) throw new PatchApplyError(`Insertion header not found: ${hunk.header}`);
+      return [...source.slice(0, idx + 1), ...replacement, ...source.slice(idx + 1)];
+    }
+    return [...source, ...replacement];
+  }
+  const matchIdx = findMatch(source, pattern, hunk.header);
+  if (matchIdx === -1) {
+    throw new PatchApplyError(
+      `Could not locate hunk context${hunk.header ? ` near "${hunk.header}"` : ""}. First context line: ${JSON.stringify(pattern[0])}`
+    );
+  }
+  return [
+    ...source.slice(0, matchIdx),
+    ...replacement,
+    ...source.slice(matchIdx + pattern.length)
+  ];
+}
+function findMatch(source, pattern, header) {
+  const start = header ? source.findIndex((l) => l.includes(header)) + 1 : 0;
+  const scanFrom = Math.max(0, start);
+  const strategies = [
+    (s) => s,
+    (s) => s.replace(/[ \t]+$/, ""),
+    (s) => s.trim()
+  ];
+  for (const norm of strategies) {
+    const normPattern = pattern.map(norm);
+    for (let i = scanFrom; i + pattern.length <= source.length; i++) {
+      let ok = true;
+      for (let j = 0; j < pattern.length; j++) {
+        if (norm(source[i + j]) !== normPattern[j]) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) return i;
+    }
+    if (header) {
+      for (let i = 0; i + pattern.length <= source.length; i++) {
+        let ok = true;
+        for (let j = 0; j < pattern.length; j++) {
+          if (norm(source[i + j]) !== normPattern[j]) {
+            ok = false;
+            break;
+          }
+        }
+        if (ok) return i;
+      }
+    }
+  }
+  return -1;
+}
+var parameters = z.object({
+  input: z.string().describe(
+    'A patch in the apply_patch format. Must begin with "*** Begin Patch" and end with "*** End Patch". Use "*** Add File: path", "*** Update File: path" (with @@ context + +/-/space lines), or "*** Delete File: path" sections. Optionally "*** Move to: path" right after Update File.'
+  )
+});
+var applyPatchTool = {
+  name: "apply_patch",
+  description: 'Apply a multi-file patch in the apply_patch format. Prefer this over the edit tool when making coordinated changes across multiple files, adding/deleting/renaming files, or when context-anchored hunks are safer than exact string match. Format: *** Begin Patch / *** Add|Update|Delete File: path / (for Update: @@ header, then lines prefixed with " ", "+", "-") / *** End Patch.',
+  parameters,
+  async execute(params, ctx) {
+    let actions;
+    try {
+      actions = parsePatch(params.input);
+    } catch (err) {
+      return { content: `Patch parse error: ${err.message}`, isError: true };
+    }
+    const summary = [];
+    try {
+      for (const action of actions) {
+        const abs = path.isAbsolute(action.target) ? action.target : path.resolve(ctx.cwd, action.target);
+        if (action.kind === "add") {
+          try {
+            await fs.access(abs);
+            return { content: `Add File failed: ${action.target} already exists`, isError: true };
+          } catch {
+          }
+          await fs.mkdir(path.dirname(abs), { recursive: true });
+          await fs.writeFile(abs, action.content, "utf-8");
+          summary.push(`A ${action.target}`);
+        } else if (action.kind === "delete") {
+          await fs.unlink(abs);
+          summary.push(`D ${action.target}`);
+        } else {
+          const original = await fs.readFile(abs, "utf-8");
+          const hasCrlf = original.includes("\r\n");
+          const eol = hasCrlf ? "\r\n" : "\n";
+          const hadTrailingNewline = original.endsWith("\n") || original.endsWith("\r\n");
+          const stripped = hasCrlf ? original.replace(/\r\n/g, "\n") : original;
+          let lines = (hadTrailingNewline ? stripped.slice(0, -1) : stripped).split("\n");
+          for (const hunk of action.hunks) {
+            lines = applyHunk(lines, hunk);
+          }
+          const joined = lines.join(eol);
+          const next = hadTrailingNewline ? joined + eol : joined;
+          const destAbs = action.moveTo ? path.isAbsolute(action.moveTo) ? action.moveTo : path.resolve(ctx.cwd, action.moveTo) : abs;
+          if (action.moveTo) {
+            await fs.mkdir(path.dirname(destAbs), { recursive: true });
+            await fs.writeFile(destAbs, next, "utf-8");
+            await fs.unlink(abs);
+            summary.push(`R ${action.target} -> ${action.moveTo}`);
+          } else {
+            await fs.writeFile(abs, next, "utf-8");
+            summary.push(`M ${action.target}`);
+          }
+        }
+      }
+    } catch (err) {
+      return {
+        content: `Patch apply failed: ${err.message}
+Partial changes may have been written. Applied so far: ${summary.join(", ") || "(none)"}`,
+        isError: true
+      };
+    }
+    return { content: `Applied patch (${actions.length} file op${actions.length === 1 ? "" : "s"}):
+${summary.join("\n")}` };
+  }
+};
+
+export {
+  PatchParseError,
+  PatchApplyError,
+  parsePatch,
+  applyHunk,
+  applyPatchTool
+};

package/dist/chunk-CQMAVWLJ.js

@@ -0,0 +1,134 @@
+// src/tools/read.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".ico"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".zip", ".tar", ".gz", ".wasm", ".exe", ".dll", ".so", ".dylib"]);
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_LINES = 2e3;
+var parameters = z.object({
+  path: z.string().describe("Relative or absolute path to the file to read"),
+  offset: z.number().optional().describe("Line number to start reading from (1-based)"),
+  limit: z.number().optional().describe("Maximum number of lines to read")
+});
+async function readImage(filePath, ext) {
+  try {
+    const stat = await fs.stat(filePath);
+    const buf = await fs.readFile(filePath);
+    const mimeType = ext === ".svg" ? "image/svg+xml" : ext === ".png" ? "image/png" : ext === ".gif" ? "image/gif" : ext === ".webp" ? "image/webp" : ext === ".bmp" ? "image/bmp" : ext === ".ico" ? "image/x-icon" : "image/jpeg";
+    if (ext === ".svg") {
+      const svgText = buf.toString("utf-8");
+      return {
+        content: `Image: ${filePath} (${(stat.size / 1024).toFixed(1)} KB, SVG)
+
+${svgText.slice(0, 1e4)}`
+      };
+    }
+    const base64 = buf.toString("base64");
+    return {
+      content: `Image: ${filePath} (${(stat.size / 1024).toFixed(1)} KB, ${ext})
+data:${mimeType};base64,${base64.slice(0, 200)}... [${base64.length} chars total]
+
+(Image data is available. Describe what changes to make if needed.)`
+    };
+  } catch (err) {
+    return { content: `Error reading image ${filePath}: ${err.message}`, isError: true };
+  }
+}
+async function readPDF(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    const buf = await fs.readFile(filePath);
+    const text = buf.toString("latin1");
+    const textChunks = [];
+    const streamRegex = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+    let match;
+    while ((match = streamRegex.exec(text)) !== null) {
+      const chunk = match[1].replace(/[^\x20-\x7E\n\r\t]/g, " ").replace(/\s+/g, " ").trim();
+      if (chunk.length > 10) {
+        textChunks.push(chunk);
+      }
+    }
+    const tjRegex = /\(((?:[^)\\]|\\.)*)\)\s*Tj/g;
+    while ((match = tjRegex.exec(text)) !== null) {
+      const decoded = match[1].replace(/\\(.)/g, "$1");
+      if (decoded.trim().length > 0) {
+        textChunks.push(decoded.trim());
+      }
+    }
+    if (textChunks.length === 0) {
+      return {
+        content: `PDF: ${filePath} (${(stat.size / 1024).toFixed(1)} KB)
+
+(Could not extract text \u2014 the PDF may be image-based or encrypted. Consider using an external tool for OCR.)`
+      };
+    }
+    const extractedText = textChunks.join("\n").slice(0, 5e4);
+    return {
+      content: `PDF: ${filePath} (${(stat.size / 1024).toFixed(1)} KB)
+
+Extracted text:
+${extractedText}`
+    };
+  } catch (err) {
+    return { content: `Error reading PDF ${filePath}: ${err.message}`, isError: true };
+  }
+}
+var readTool = {
+  name: "read",
+  description: 'Read file contents with line numbers. Use offset/limit for large files. Supports text files, images (returns metadata + base64), and PDFs (basic text extraction). Returns numbered lines like "  1\\tline content".',
+  parameters,
+  async execute(params, ctx) {
+    const filePath = path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path);
+    const ext = path.extname(filePath).toLowerCase();
+    try {
+      await fs.access(filePath);
+      if (IMAGE_EXTENSIONS.has(ext)) {
+        return await readImage(filePath, ext);
+      }
+      if (ext === ".pdf") {
+        return await readPDF(filePath);
+      }
+      if (BINARY_EXTENSIONS.has(ext)) {
+        const stat2 = await fs.stat(filePath);
+        return {
+          content: `Binary file: ${filePath} (${(stat2.size / 1024).toFixed(1)} KB, ${ext})`
+        };
+      }
+      const stat = await fs.stat(filePath);
+      if (stat.size > MAX_FILE_SIZE) {
+        return {
+          content: `File too large: ${filePath} (${(stat.size / 1024 / 1024).toFixed(1)} MB). Use offset/limit to read portions.`,
+          isError: true
+        };
+      }
+      const cacheKey = `${filePath}:${params.offset ?? 0}:${params.limit ?? 0}`;
+      if (ctx._readCache?.has(cacheKey)) {
+        return { content: ctx._readCache.get(cacheKey) };
+      }
+      const raw = await fs.readFile(filePath, "utf-8");
+      const allLines = raw.split("\n");
+      const offset = Math.max(0, (params.offset ?? 1) - 1);
+      const limit = params.limit ?? MAX_LINES;
+      const lines = allLines.slice(offset, offset + limit);
+      const numbered = lines.map((line, i) => {
+        const lineNum = String(offset + i + 1).padStart(5);
+        return `${lineNum}	${line}`;
+      }).join("\n");
+      const result = allLines.length > offset + limit ? `${numbered}
+
+(${allLines.length - offset - limit} more lines. Use offset=${offset + limit + 1} to continue.)` : numbered;
+      ctx._readCache?.set(cacheKey, result);
+      return { content: result };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { content: `File not found: ${filePath}`, isError: true };
+      }
+      return { content: `Error reading ${filePath}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  readTool
+};

package/dist/chunk-FAULT7VE.js

@@ -0,0 +1,139 @@
+// src/tools/git.ts
+import { simpleGit } from "simple-git";
+import { z } from "zod";
+var PROTECTED_BRANCHES = ["main", "master", "production", "release"];
+var parameters = z.object({
+  operation: z.enum([
+    "status",
+    "diff",
+    "log",
+    "commit",
+    "branch",
+    "checkout",
+    "push",
+    "pull",
+    "stash",
+    "add",
+    "show"
+  ]).describe("Git operation to perform"),
+  args: z.string().optional().describe("Additional arguments (e.g., branch name, commit message, file paths)")
+});
+var gitTool = {
+  name: "git",
+  description: "Perform git operations with built-in safety. Always prefer this over shell for git commands. Blocks force-push to protected branches. Operations: status, diff, log, commit, branch, checkout, push, pull, stash, add, show.",
+  parameters,
+  async execute(params, ctx) {
+    const git = simpleGit(ctx.cwd);
+    try {
+      switch (params.operation) {
+        case "status": {
+          const status = await git.status();
+          const lines = [
+            `Branch: ${status.current}`,
+            `Ahead: ${status.ahead} Behind: ${status.behind}`,
+            status.staged.length ? `Staged: ${status.staged.join(", ")}` : null,
+            status.modified.length ? `Modified: ${status.modified.join(", ")}` : null,
+            status.not_added.length ? `Untracked: ${status.not_added.join(", ")}` : null,
+            status.deleted.length ? `Deleted: ${status.deleted.join(", ")}` : null
+          ].filter(Boolean);
+          return { content: lines.join("\n") };
+        }
+        case "diff": {
+          const diff = await git.diff(params.args?.split(" ") ?? []);
+          return { content: diff || "(no changes)" };
+        }
+        case "log": {
+          const log = await git.log({ maxCount: 10, ...params.args ? {} : {} });
+          const entries = log.all.map(
+            (c) => `${c.hash.slice(0, 8)} ${c.date} ${c.message}`
+          );
+          return { content: entries.join("\n") || "(no commits)" };
+        }
+        case "commit": {
+          if (!params.args) {
+            return { content: 'Commit requires a message. Use args: "your commit message"', isError: true };
+          }
+          const result = await git.commit(params.args);
+          return {
+            content: `Committed: ${result.commit} (${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions)`
+          };
+        }
+        case "add": {
+          const files = params.args?.split(" ") ?? ["."];
+          const sensitive = files.filter(
+            (f) => /\.(env|pem|key|credentials|secret)/i.test(f)
+          );
+          if (sensitive.length > 0) {
+            const confirmed = await ctx.confirm(
+              `\u26A0 Staging potentially sensitive files: ${sensitive.join(", ")}
+Proceed?`
+            );
+            if (!confirmed) {
+              return { content: "Staging cancelled.", isError: true };
+            }
+          }
+          await git.add(files);
+          return { content: `Staged: ${files.join(", ")}` };
+        }
+        case "branch": {
+          if (params.args) {
+            await git.branch(params.args.split(" "));
+            return { content: `Branch operation completed: ${params.args}` };
+          }
+          const branches = await git.branch();
+          return { content: branches.all.map((b) => `${b === branches.current ? "* " : "  "}${b}`).join("\n") };
+        }
+        case "checkout": {
+          if (!params.args) {
+            return { content: "Checkout requires a branch or file path.", isError: true };
+          }
+          await git.checkout(params.args.split(" "));
+          return { content: `Checked out: ${params.args}` };
+        }
+        case "push": {
+          const currentBranch = (await git.status()).current ?? "";
+          const args = params.args?.split(" ") ?? [];
+          const isForce = args.includes("--force") || args.includes("-f");
+          if (isForce && PROTECTED_BRANCHES.includes(currentBranch)) {
+            return {
+              content: `Blocked: cannot force-push to protected branch "${currentBranch}". Use --force-with-lease instead.`,
+              isError: true
+            };
+          }
+          await git.push(args);
+          return { content: `Pushed ${currentBranch} successfully` };
+        }
+        case "pull": {
+          const pullResult = await git.pull(params.args?.split(" "));
+          return {
+            content: `Pulled: ${pullResult.summary.changes} changes, ${pullResult.summary.insertions} insertions, ${pullResult.summary.deletions} deletions`
+          };
+        }
+        case "stash": {
+          if (params.args === "pop") {
+            await git.stash(["pop"]);
+            return { content: "Stash popped" };
+          }
+          if (params.args === "list") {
+            const list = await git.stashList();
+            return { content: list.all.map((s) => `${s.hash} ${s.message}`).join("\n") || "(no stashes)" };
+          }
+          await git.stash(params.args?.split(" "));
+          return { content: "Changes stashed" };
+        }
+        case "show": {
+          const raw = await git.show(params.args?.split(" ") ?? []);
+          return { content: raw };
+        }
+        default:
+          return { content: `Unknown git operation: ${params.operation}`, isError: true };
+      }
+    } catch (err) {
+      return { content: `Git error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  gitTool
+};

package/dist/chunk-FFB7GK3Y.js

@@ -0,0 +1,72 @@
+// src/tools/web-fetch.ts
+import { z } from "zod";
+var MAX_CONTENT_LENGTH = 5e4;
+var FETCH_TIMEOUT = 15e3;
+var parameters = z.object({
+  url: z.string().describe("URL to fetch"),
+  max_length: z.number().optional().default(MAX_CONTENT_LENGTH).describe("Max characters to return")
+});
+function htmlToText(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<nav[\s\S]*?<\/nav>/gi, "").replace(/<footer[\s\S]*?<\/footer>/gi, "").replace(/<header[\s\S]*?<\/header>/gi, "").replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote|pre|hr)[^>]*>/gi, "\n").replace(/<li[^>]*>/gi, "\n- ").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").replace(/[ \t]+/g, " ").trim();
+}
+var webFetchTool = {
+  name: "web_fetch",
+  description: "Fetch a web page and return its text content. Useful for reading documentation, API references, error lookups, and other web resources. Strips HTML to plain text.",
+  parameters,
+  async execute(params, _ctx) {
+    const { url } = params;
+    const maxLen = params.max_length ?? MAX_CONTENT_LENGTH;
+    try {
+      new URL(url);
+    } catch {
+      return { content: `Invalid URL: ${url}`, isError: true };
+    }
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+        headers: {
+          "User-Agent": "Notch-CLI/0.1 (AI coding assistant)",
+          "Accept": "text/html,application/json,text/plain"
+        },
+        redirect: "follow"
+      });
+      if (!response.ok) {
+        return {
+          content: `HTTP ${response.status} ${response.statusText} for ${url}`,
+          isError: true
+        };
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const raw = await response.text();
+      let text;
+      if (contentType.includes("application/json")) {
+        try {
+          text = JSON.stringify(JSON.parse(raw), null, 2);
+        } catch {
+          text = raw;
+        }
+      } else if (contentType.includes("text/html")) {
+        text = htmlToText(raw);
+      } else {
+        text = raw;
+      }
+      if (text.length > maxLen) {
+        text = text.slice(0, maxLen) + `
+
+... (truncated, ${text.length} chars total)`;
+      }
+      return { content: `Fetched ${url} (${response.status}):
+
+${text}` };
+    } catch (err) {
+      if (err.name === "AbortError" || err.name === "TimeoutError") {
+        return { content: `Timeout fetching ${url} (${FETCH_TIMEOUT / 1e3}s limit)`, isError: true };
+      }
+      return { content: `Fetch error for ${url}: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  webFetchTool
+};