@freesyntax/notch-cli 0.5.17 → 0.5.19

package/dist/apply-patch-EBZ5VLO7.js

@@ -0,0 +1,15 @@
+import {
+  PatchApplyError,
+  PatchParseError,
+  applyHunk,
+  applyPatchTool,
+  parsePatch
+} from "./chunk-C4CPDDMN.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  PatchApplyError,
+  PatchParseError,
+  applyHunk,
+  applyPatchTool,
+  parsePatch
+};

package/dist/chunk-3QUV4JEX.js

@@ -0,0 +1,162 @@
+// src/plugins/discovery.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+async function discoverPlugins(projectRoot) {
+  const globalDir = path.join(os.homedir(), ".notch", "plugins");
+  const projectDir = path.join(projectRoot, ".notch", "plugins");
+  const plugins = /* @__PURE__ */ new Map();
+  for (const plugin of await scanDirectory(globalDir)) {
+    plugins.set(plugin.name, plugin);
+  }
+  for (const plugin of await scanDirectory(projectDir)) {
+    plugins.set(plugin.name, plugin);
+  }
+  return [...plugins.values()];
+}
+async function scanDirectory(dir) {
+  const results = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pluginDir = path.join(dir, entry.name);
+      const pkgPath = path.join(pluginDir, "package.json");
+      try {
+        const raw = await fs.readFile(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg["notch-plugin"] && pkg.name) {
+          results.push({
+            name: pkg.name,
+            version: pkg.version ?? "0.0.0",
+            description: pkg.description ?? "",
+            path: pluginDir,
+            manifest: pkg["notch-plugin"]
+          });
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/plugins/loader.ts
+import path2 from "path";
+import { pathToFileURL } from "url";
+
+// src/commands/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerCommand(name, handler) {
+  registry.set(name, handler);
+}
+async function dispatchCommand(input, ctx) {
+  for (const [name, handler] of registry) {
+    if (input === name || input.startsWith(name + " ")) {
+      const args = input.slice(name.length).trim();
+      await handler(args, ctx);
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/plugins/loader.ts
+async function loadPlugin(discovered, projectRoot, log) {
+  const entryPath = path2.resolve(discovered.path, discovered.manifest.main);
+  const tools = [];
+  const hooks = [];
+  const ctx = {
+    cwd: projectRoot,
+    log,
+    registerTool(tool) {
+      tools.push(tool);
+    },
+    registerCommand(name, handler) {
+      registerCommand(name, handler);
+    },
+    registerHook(hook) {
+      hooks.push(hook);
+    }
+  };
+  try {
+    const moduleUrl = pathToFileURL(entryPath).href;
+    const mod = await import(moduleUrl);
+    const plugin = mod.default ?? mod;
+    if (typeof plugin.activate !== "function") {
+      log(`Plugin ${discovered.name}: no activate() function \u2014 skipping`);
+      return null;
+    }
+    await plugin.activate(ctx);
+    return {
+      name: discovered.name,
+      version: discovered.version,
+      description: discovered.description,
+      path: discovered.path,
+      instance: plugin,
+      tools,
+      hooks
+    };
+  } catch (err) {
+    log(`Plugin ${discovered.name} failed to load: ${err.message}`);
+    return null;
+  }
+}
+
+// src/plugins/index.ts
+var PluginManager = class {
+  plugins = [];
+  initialized = false;
+  /**
+   * Discover and load all plugins. Call once at startup.
+   */
+  async init(projectRoot, log) {
+    if (this.initialized) return this.plugins.length;
+    const discovered = await discoverPlugins(projectRoot);
+    if (discovered.length === 0) {
+      this.initialized = true;
+      return 0;
+    }
+    for (const d of discovered) {
+      const loaded = await loadPlugin(d, projectRoot, log);
+      if (loaded) {
+        this.plugins.push(loaded);
+      }
+    }
+    this.initialized = true;
+    return this.plugins.length;
+  }
+  /** All tools registered by plugins */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getTools() {
+    return this.plugins.flatMap((p) => p.tools);
+  }
+  /** All hooks registered by plugins */
+  getHooks() {
+    return this.plugins.flatMap((p) => p.hooks);
+  }
+  /** List all loaded plugins */
+  list() {
+    return [...this.plugins];
+  }
+  /** Shut down all plugins gracefully */
+  async shutdown() {
+    for (const p of this.plugins) {
+      try {
+        await p.instance.deactivate?.();
+      } catch (err) {
+        console.warn(`  Plugin ${p.name} deactivation failed: ${err.message}`);
+      }
+    }
+    this.plugins = [];
+    this.initialized = false;
+  }
+};
+var pluginManager = new PluginManager();
+
+export {
+  registerCommand,
+  dispatchCommand,
+  pluginManager
+};

package/dist/chunk-6CZCFY6H.js

@@ -0,0 +1,98 @@
+// src/tools/grep.ts
+import { execSync } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  pattern: z.string().describe("Regex pattern to search for"),
+  path: z.string().optional().describe("File or directory to search (defaults to project root)"),
+  glob: z.string().optional().describe('Glob filter, e.g. "*.ts" or "**/*.tsx"'),
+  context: z.number().optional().default(0).describe("Lines of context around each match"),
+  max_results: z.number().optional().default(50).describe("Maximum number of matches to return")
+});
+var grepTool = {
+  name: "grep",
+  description: "Search file contents by regex pattern. Returns matching lines with file paths and line numbers. Supports glob filtering and context lines.",
+  parameters,
+  async execute(params, ctx) {
+    const searchPath = params.path ? path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path) : ctx.cwd;
+    try {
+      const rgArgs = [
+        "rg",
+        "--no-heading",
+        "--line-number",
+        "--color=never",
+        `--max-count=${params.max_results}`,
+        params.context ? `-C ${params.context}` : "",
+        params.glob ? `--glob "${params.glob}"` : "",
+        "--",
+        JSON.stringify(params.pattern),
+        searchPath
+      ].filter(Boolean).join(" ");
+      const output = execSync(rgArgs, {
+        cwd: ctx.cwd,
+        encoding: "utf-8",
+        timeout: 15e3,
+        maxBuffer: 5 * 1024 * 1024
+      });
+      return { content: output || "(no matches)" };
+    } catch {
+    }
+    try {
+      const regex = new RegExp(params.pattern, "g");
+      const results = [];
+      async function searchDir(dir) {
+        if (results.length >= (params.max_results ?? 50)) return;
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (results.length >= (params.max_results ?? 50)) return;
+          if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+          const full = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            await searchDir(full);
+          } else if (entry.isFile()) {
+            if (params.glob) {
+              const ext = params.glob.replace(/^\*+\.?/, "");
+              if (ext && !entry.name.endsWith(ext)) continue;
+            }
+            try {
+              const content = await fs.readFile(full, "utf-8");
+              const lines = content.split("\n");
+              for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                  const rel = path.relative(ctx.cwd, full);
+                  results.push(`${rel}:${i + 1}:${lines[i]}`);
+                  regex.lastIndex = 0;
+                  if (results.length >= (params.max_results ?? 50)) return;
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      const stat = await fs.stat(searchPath);
+      if (stat.isFile()) {
+        const content = await fs.readFile(searchPath, "utf-8");
+        const lines = content.split("\n");
+        const rel = path.relative(ctx.cwd, searchPath);
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            results.push(`${rel}:${i + 1}:${lines[i]}`);
+            regex.lastIndex = 0;
+            if (results.length >= (params.max_results ?? 50)) break;
+          }
+        }
+      } else {
+        await searchDir(searchPath);
+      }
+      return { content: results.join("\n") || "(no matches)" };
+    } catch (err) {
+      return { content: `Search error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  grepTool
+};

package/dist/chunk-6U3ZAGYA.js

@@ -0,0 +1,38 @@
+// src/tools/glob.ts
+import { glob as globFn } from "glob";
+import path from "path";
+import { z } from "zod";
+var parameters = z.object({
+  pattern: z.string().describe('Glob pattern, e.g. "**/*.ts" or "src/**/*.tsx"'),
+  path: z.string().optional().describe("Directory to search (defaults to project root)")
+});
+var globTool = {
+  name: "glob",
+  description: "Find files matching a glob pattern. Returns relative paths sorted by modification time. Ignores node_modules and .git by default.",
+  parameters,
+  async execute(params, ctx) {
+    const searchDir = params.path ? path.isAbsolute(params.path) ? params.path : path.resolve(ctx.cwd, params.path) : ctx.cwd;
+    try {
+      const matches = await globFn(params.pattern, {
+        cwd: searchDir,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"],
+        nodir: true,
+        dot: false
+      });
+      if (matches.length === 0) {
+        return { content: `No files matching "${params.pattern}" in ${path.relative(ctx.cwd, searchDir) || "."}` };
+      }
+      const relative = matches.map((m) => path.relative(ctx.cwd, path.resolve(searchDir, m)));
+      return {
+        content: `Found ${relative.length} file(s):
+${relative.join("\n")}`
+      };
+    } catch (err) {
+      return { content: `Glob error: ${err.message}`, isError: true };
+    }
+  }
+};
+
+export {
+  globTool
+};