@moxxy/agent-cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1982 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/plugin-registry.ts
+var PluginRegistry;
+var init_plugin_registry = __esm({
+  "src/core/plugin-registry.ts"() {
+    "use strict";
+    PluginRegistry = class {
+      plugins = /* @__PURE__ */ new Map();
+      register(plugin) {
+        this.plugins.set(plugin.name, plugin);
+      }
+      get(name) {
+        return this.plugins.get(name);
+      }
+      getAll() {
+        return Array.from(this.plugins.values());
+      }
+      has(name) {
+        return this.plugins.has(name);
+      }
+    };
+  }
+});
+
+// src/core/exec.ts
+function exec(command, args, options) {
+  return new Promise((resolve14, reject) => {
+    (0, import_node_child_process.execFile)(
+      command,
+      args,
+      { ...options, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(Object.assign(error, { stdout, stderr }));
+        } else {
+          resolve14({ stdout, stderr });
+        }
+      }
+    );
+  });
+}
+var import_node_child_process;
+var init_exec = __esm({
+  "src/core/exec.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+  }
+});
+
+// src/core/context.ts
+async function detectWorkspace(cwd) {
+  const context = {
+    cwd,
+    isGitRepo: false
+  };
+  try {
+    const { stdout } = await exec("git", ["rev-parse", "--show-toplevel"], { cwd });
+    context.isGitRepo = true;
+    context.repoRoot = stdout.trim();
+  } catch {
+    context.isGitRepo = false;
+  }
+  if (context.isGitRepo) {
+    try {
+      const { stdout } = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+      context.branch = stdout.trim();
+    } catch {
+    }
+  }
+  const lockfiles = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "bun.lockb", manager: "bun" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  const searchDir = context.repoRoot || cwd;
+  for (const { file, manager } of lockfiles) {
+    if (fs.existsSync(path.join(searchDir, file))) {
+      context.packageManager = manager;
+      break;
+    }
+  }
+  currentContext = context;
+  return context;
+}
+function getContext() {
+  return currentContext;
+}
+var fs, path, currentContext;
+var init_context = __esm({
+  "src/core/context.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    init_exec();
+    currentContext = null;
+  }
+});
+
+// src/core/result.ts
+function success(command, data, startTime) {
+  return {
+    success: true,
+    command,
+    data,
+    duration_ms: Date.now() - startTime
+  };
+}
+function failure(command, code, message, startTime, details) {
+  return {
+    success: false,
+    command,
+    error: { code, message, details },
+    duration_ms: Date.now() - startTime
+  };
+}
+function output(result) {
+  process.stdout.write(JSON.stringify(result) + "\n");
+}
+function log(message) {
+  process.stderr.write(message + "\n");
+}
+var init_result = __esm({
+  "src/core/result.ts"() {
+    "use strict";
+  }
+});
+
+// src/plugins/workspace/init.ts
+function registerInit(parent) {
+  parent.command("init").description("Initialize a workspace by cloning a repo and setting up the environment").option("--repo <url>", "Git repository URL to clone").option("--branch <name>", "Branch to create or checkout").option("--clone-dir <path>", "Directory to clone into").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "workspace init";
+    try {
+      if (!opts.repo) {
+        output(failure(cmd, "MISSING_ARGUMENT", "--repo is required", startTime));
+        return;
+      }
+      const cloneDir = opts.cloneDir || process.cwd();
+      log(`Cloning ${opts.repo} into ${cloneDir}...`);
+      const cloneArgs = ["clone", opts.repo, cloneDir];
+      await exec("git", cloneArgs);
+      if (opts.branch) {
+        log(`Creating and checking out branch ${opts.branch}...`);
+        await exec("git", ["checkout", "-b", opts.branch], { cwd: cloneDir });
+      }
+      const context = await detectWorkspace(cloneDir);
+      if (context.packageManager) {
+        log(`Detected ${context.packageManager}, installing dependencies...`);
+        try {
+          await exec(context.packageManager, ["install"], { cwd: cloneDir });
+        } catch (err) {
+          log(`Warning: dependency install failed: ${err.message}`);
+        }
+      }
+      output(success(cmd, {
+        path: cloneDir,
+        repo: opts.repo,
+        branch: opts.branch || context.branch,
+        packageManager: context.packageManager,
+        isGitRepo: context.isGitRepo
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "WORKSPACE_INIT_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_init = __esm({
+  "src/plugins/workspace/init.ts"() {
+    "use strict";
+    init_exec();
+    init_context();
+    init_result();
+  }
+});
+
+// src/plugins/workspace/info.ts
+function registerInfo(parent) {
+  parent.command("info").description("Display current workspace context").action(async () => {
+    const startTime = Date.now();
+    const cmd = "workspace info";
+    try {
+      const cwd = parent.optsWithGlobals().cwd || process.cwd();
+      const context = await detectWorkspace(cwd);
+      output(success(cmd, context, startTime));
+    } catch (err) {
+      output(failure(cmd, "WORKSPACE_INFO_ERROR", err.message, startTime));
+    }
+  });
+}
+var init_info = __esm({
+  "src/plugins/workspace/info.ts"() {
+    "use strict";
+    init_context();
+    init_result();
+  }
+});
+
+// src/plugins/workspace/clean.ts
+function registerClean(parent) {
+  parent.command("clean").description("Remove workspace directory").argument("<path>", "Workspace directory to remove").action(async (targetPath) => {
+    const startTime = Date.now();
+    const cmd = "workspace clean";
+    try {
+      if (!fs2.existsSync(targetPath)) {
+        output(failure(cmd, "NOT_FOUND", `Directory not found: ${targetPath}`, startTime));
+        return;
+      }
+      log(`Removing ${targetPath}...`);
+      fs2.rmSync(targetPath, { recursive: true, force: true });
+      output(success(cmd, { path: targetPath, removed: true }, startTime));
+    } catch (err) {
+      output(failure(cmd, "WORKSPACE_CLEAN_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs2;
+var init_clean = __esm({
+  "src/plugins/workspace/clean.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"));
+    init_result();
+  }
+});
+
+// src/plugins/workspace/index.ts
+var WorkspacePlugin;
+var init_workspace = __esm({
+  "src/plugins/workspace/index.ts"() {
+    "use strict";
+    init_init();
+    init_info();
+    init_clean();
+    WorkspacePlugin = class {
+      name = "workspace";
+      version = "1.0.0";
+      description = "Workspace initialization and management";
+      register(program) {
+        const workspace = program.command("workspace").description(this.description);
+        registerInit(workspace);
+        registerInfo(workspace);
+        registerClean(workspace);
+      }
+      getCommands() {
+        return [
+          {
+            name: "workspace init",
+            description: "Clone a repo and set up workspace",
+            args: [],
+            options: [
+              { name: "--repo", description: "Git repository URL", required: true, type: "string" },
+              { name: "--branch", description: "Branch to create", required: false, type: "string" },
+              { name: "--clone-dir", description: "Clone target directory", required: false, type: "string" }
+            ],
+            examples: ["moxxy-agent workspace init --repo https://github.com/org/repo --branch feat/new"]
+          },
+          {
+            name: "workspace info",
+            description: "Display current workspace context",
+            args: [],
+            options: [],
+            examples: ["moxxy-agent workspace info"]
+          },
+          {
+            name: "workspace clean",
+            description: "Remove workspace directory",
+            args: [{ name: "path", description: "Directory to remove", required: true, type: "string" }],
+            options: [],
+            examples: ["moxxy-agent workspace clean /tmp/workspace"]
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/file/create.ts
+function registerCreate(parent) {
+  parent.command("create").description("Create a new file").argument("<path>", "File path to create").option("--content <text>", "File content").option("--from-stdin", "Read content from stdin").action(async (filePath, opts) => {
+    const startTime = Date.now();
+    const cmd = "file create";
+    try {
+      const resolvedPath = path2.resolve(filePath);
+      const dir = path2.dirname(resolvedPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+      let content = opts.content || "";
+      if (opts.fromStdin) {
+        content = await readStdin();
+      }
+      fs3.writeFileSync(resolvedPath, content, "utf-8");
+      const stats = fs3.statSync(resolvedPath);
+      output(success(cmd, { path: resolvedPath, size: stats.size }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_CREATE_ERROR", err.message, startTime));
+    }
+  });
+}
+function readStdin() {
+  return new Promise((resolve14, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve14(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+var fs3, path2;
+var init_create = __esm({
+  "src/plugins/file/create.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/read.ts
+function registerRead(parent) {
+  parent.command("read").description("Read a file").argument("<path>", "File path to read").option("--lines <range>", "Line range, e.g. 1:10").action(async (filePath, opts) => {
+    const startTime = Date.now();
+    const cmd = "file read";
+    try {
+      const resolvedPath = path3.resolve(filePath);
+      if (!fs4.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `File not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      const raw = fs4.readFileSync(resolvedPath, "utf-8");
+      let lines = raw.split("\n");
+      let startLine = 1;
+      let endLine = lines.length;
+      if (opts.lines) {
+        const parts = opts.lines.split(":");
+        startLine = Math.max(1, parseInt(parts[0], 10) || 1);
+        endLine = parts[1] ? parseInt(parts[1], 10) || lines.length : lines.length;
+        lines = lines.slice(startLine - 1, endLine);
+      }
+      output(success(cmd, {
+        path: resolvedPath,
+        content: lines.join("\n"),
+        lines: lines.length,
+        startLine,
+        endLine: Math.min(endLine, startLine + lines.length - 1)
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_READ_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs4, path3;
+var init_read = __esm({
+  "src/plugins/file/read.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/update.ts
+function registerUpdate(parent) {
+  parent.command("update").description("Overwrite a file with new content").argument("<path>", "File path to update").option("--content <text>", "New file content").option("--from-stdin", "Read content from stdin").action(async (filePath, opts) => {
+    const startTime = Date.now();
+    const cmd = "file update";
+    try {
+      const resolvedPath = path4.resolve(filePath);
+      if (!fs5.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `File not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      let content = opts.content || "";
+      if (opts.fromStdin) {
+        content = await readStdin2();
+      }
+      fs5.writeFileSync(resolvedPath, content, "utf-8");
+      const stats = fs5.statSync(resolvedPath);
+      output(success(cmd, { path: resolvedPath, size: stats.size }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_UPDATE_ERROR", err.message, startTime));
+    }
+  });
+}
+function readStdin2() {
+  return new Promise((resolve14, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve14(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("error", reject);
+  });
+}
+var fs5, path4;
+var init_update = __esm({
+  "src/plugins/file/update.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/delete.ts
+function registerDelete(parent) {
+  parent.command("delete").description("Delete a file").argument("<path>", "File path to delete").action(async (filePath) => {
+    const startTime = Date.now();
+    const cmd = "file delete";
+    try {
+      const resolvedPath = path5.resolve(filePath);
+      if (!fs6.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `File not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      fs6.unlinkSync(resolvedPath);
+      output(success(cmd, { path: resolvedPath, deleted: true }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_DELETE_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs6, path5;
+var init_delete = __esm({
+  "src/plugins/file/delete.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/move.ts
+function registerMove(parent) {
+  parent.command("move").description("Move or rename a file").argument("<source>", "Source file path").argument("<dest>", "Destination file path").action(async (source, dest) => {
+    const startTime = Date.now();
+    const cmd = "file move";
+    try {
+      const resolvedSource = path6.resolve(source);
+      const resolvedDest = path6.resolve(dest);
+      if (!fs7.existsSync(resolvedSource)) {
+        output(failure(cmd, "NOT_FOUND", `Source file not found: ${resolvedSource}`, startTime));
+        return;
+      }
+      const destDir = path6.dirname(resolvedDest);
+      if (!fs7.existsSync(destDir)) {
+        fs7.mkdirSync(destDir, { recursive: true });
+      }
+      fs7.renameSync(resolvedSource, resolvedDest);
+      output(success(cmd, { source: resolvedSource, dest: resolvedDest }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_MOVE_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs7, path6;
+var init_move = __esm({
+  "src/plugins/file/move.ts"() {
+    "use strict";
+    fs7 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/patch.ts
+function registerPatch(parent) {
+  parent.command("patch").description("Replace a string in a file").argument("<path>", "File path to patch").requiredOption("--search <text>", "String to search for").requiredOption("--replace <text>", "Replacement string").action(async (filePath, opts) => {
+    const startTime = Date.now();
+    const cmd = "file patch";
+    try {
+      const resolvedPath = path7.resolve(filePath);
+      if (!fs8.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `File not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      const content = fs8.readFileSync(resolvedPath, "utf-8");
+      if (!content.includes(opts.search)) {
+        output(failure(
+          cmd,
+          "SEARCH_NOT_FOUND",
+          `Search string not found in ${resolvedPath}`,
+          startTime
+        ));
+        return;
+      }
+      let replacements = 0;
+      let idx = 0;
+      while ((idx = content.indexOf(opts.search, idx)) !== -1) {
+        replacements++;
+        idx += opts.search.length;
+      }
+      const newContent = content.replaceAll(opts.search, opts.replace);
+      fs8.writeFileSync(resolvedPath, newContent, "utf-8");
+      output(success(cmd, { path: resolvedPath, replacements }, startTime));
+    } catch (err) {
+      output(failure(cmd, "FILE_PATCH_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs8, path7;
+var init_patch = __esm({
+  "src/plugins/file/patch.ts"() {
+    "use strict";
+    fs8 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/file/index.ts
+var FilePlugin;
+var init_file = __esm({
+  "src/plugins/file/index.ts"() {
+    "use strict";
+    init_create();
+    init_read();
+    init_update();
+    init_delete();
+    init_move();
+    init_patch();
+    FilePlugin = class {
+      name = "file";
+      version = "1.0.0";
+      description = "File operations (create, read, update, delete, move, patch)";
+      register(program) {
+        const file = program.command("file").description(this.description);
+        registerCreate(file);
+        registerRead(file);
+        registerUpdate(file);
+        registerDelete(file);
+        registerMove(file);
+        registerPatch(file);
+      }
+      getCommands() {
+        return [
+          {
+            name: "file create",
+            description: "Create a new file",
+            args: [{ name: "path", description: "File path", required: true, type: "string" }],
+            options: [
+              { name: "--content", description: "File content", required: false, type: "string" },
+              { name: "--from-stdin", description: "Read from stdin", required: false, type: "boolean" }
+            ],
+            examples: ['moxxy-agent file create src/main.ts --content "console.log(1)"']
+          },
+          {
+            name: "file read",
+            description: "Read a file",
+            args: [{ name: "path", description: "File path", required: true, type: "string" }],
+            options: [
+              { name: "--lines", description: "Line range (start:end)", required: false, type: "string" }
+            ],
+            examples: ["moxxy-agent file read src/main.ts --lines 1:10"]
+          },
+          {
+            name: "file update",
+            description: "Overwrite a file",
+            args: [{ name: "path", description: "File path", required: true, type: "string" }],
+            options: [
+              { name: "--content", description: "New content", required: false, type: "string" },
+              { name: "--from-stdin", description: "Read from stdin", required: false, type: "boolean" }
+            ],
+            examples: ['moxxy-agent file update src/main.ts --content "updated"']
+          },
+          {
+            name: "file delete",
+            description: "Delete a file",
+            args: [{ name: "path", description: "File path", required: true, type: "string" }],
+            options: [],
+            examples: ["moxxy-agent file delete src/old.ts"]
+          },
+          {
+            name: "file move",
+            description: "Move or rename a file",
+            args: [
+              { name: "source", description: "Source path", required: true, type: "string" },
+              { name: "dest", description: "Destination path", required: true, type: "string" }
+            ],
+            options: [],
+            examples: ["moxxy-agent file move src/old.ts src/new.ts"]
+          },
+          {
+            name: "file patch",
+            description: "Replace a string in a file",
+            args: [{ name: "path", description: "File path", required: true, type: "string" }],
+            options: [
+              { name: "--search", description: "String to find", required: true, type: "string" },
+              { name: "--replace", description: "Replacement string", required: true, type: "string" }
+            ],
+            examples: ['moxxy-agent file patch src/main.ts --search "old" --replace "new"']
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/dir/list.ts
+function registerList(parent) {
+  parent.command("list").description("List directory entries").argument("[path]", "Directory path", ".").option("--recursive", "List recursively").option("--pattern <glob>", "Filter by glob pattern").action(async (dirPath, opts) => {
+    const startTime = Date.now();
+    const cmd = "dir list";
+    try {
+      const resolvedPath = path8.resolve(dirPath);
+      if (!fs9.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `Directory not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      if (!fs9.statSync(resolvedPath).isDirectory()) {
+        output(failure(cmd, "NOT_A_DIRECTORY", `Not a directory: ${resolvedPath}`, startTime));
+        return;
+      }
+      let entries;
+      if (opts.pattern || opts.recursive) {
+        const pattern = opts.pattern || (opts.recursive ? "**/*" : "*");
+        const matches = await (0, import_glob.glob)(pattern, {
+          cwd: resolvedPath,
+          dot: false,
+          nodir: false,
+          stat: true,
+          withFileTypes: true
+        });
+        entries = matches.map((entry) => ({
+          name: entry.relative(),
+          type: entry.isDirectory() ? "directory" : "file",
+          size: entry.isDirectory() ? 0 : fs9.statSync(path8.join(resolvedPath, entry.relative())).size
+        }));
+      } else {
+        const dirEntries = fs9.readdirSync(resolvedPath, { withFileTypes: true });
+        entries = dirEntries.map((entry) => ({
+          name: entry.name,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: entry.isDirectory() ? 0 : fs9.statSync(path8.join(resolvedPath, entry.name)).size
+        }));
+      }
+      output(success(cmd, { path: resolvedPath, entries, count: entries.length }, startTime));
+    } catch (err) {
+      output(failure(cmd, "DIR_LIST_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs9, path8, import_glob;
+var init_list = __esm({
+  "src/plugins/dir/list.ts"() {
+    "use strict";
+    fs9 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
+    import_glob = require("glob");
+    init_result();
+  }
+});
+
+// src/plugins/dir/create.ts
+function registerCreate2(parent) {
+  parent.command("create").description("Create a directory recursively").argument("<path>", "Directory path to create").action(async (dirPath) => {
+    const startTime = Date.now();
+    const cmd = "dir create";
+    try {
+      const resolvedPath = path9.resolve(dirPath);
+      fs10.mkdirSync(resolvedPath, { recursive: true });
+      output(success(cmd, { path: resolvedPath, created: true }, startTime));
+    } catch (err) {
+      output(failure(cmd, "DIR_CREATE_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs10, path9;
+var init_create2 = __esm({
+  "src/plugins/dir/create.ts"() {
+    "use strict";
+    fs10 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/dir/delete.ts
+function registerDelete2(parent) {
+  parent.command("delete").description("Remove a directory").argument("<path>", "Directory path to remove").action(async (dirPath) => {
+    const startTime = Date.now();
+    const cmd = "dir delete";
+    try {
+      const resolvedPath = path10.resolve(dirPath);
+      if (!fs11.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `Directory not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      fs11.rmSync(resolvedPath, { recursive: true, force: true });
+      output(success(cmd, { path: resolvedPath, deleted: true }, startTime));
+    } catch (err) {
+      output(failure(cmd, "DIR_DELETE_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs11, path10;
+var init_delete2 = __esm({
+  "src/plugins/dir/delete.ts"() {
+    "use strict";
+    fs11 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/dir/tree.ts
+function buildTree(dirPath, currentDepth, maxDepth) {
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  const entries = fs12.readdirSync(dirPath, { withFileTypes: true });
+  const nodes = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") {
+      continue;
+    }
+    const node = {
+      name: entry.name,
+      type: entry.isDirectory() ? "directory" : "file"
+    };
+    if (entry.isDirectory()) {
+      node.children = buildTree(
+        path11.join(dirPath, entry.name),
+        currentDepth + 1,
+        maxDepth
+      );
+    }
+    nodes.push(node);
+  }
+  return nodes.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function registerTree(parent) {
+  parent.command("tree").description("Display directory tree structure").argument("[path]", "Directory path", ".").option("--depth <n>", "Maximum depth", "3").action(async (dirPath, opts) => {
+    const startTime = Date.now();
+    const cmd = "dir tree";
+    try {
+      const resolvedPath = path11.resolve(dirPath);
+      const maxDepth = parseInt(opts.depth, 10) || 3;
+      if (!fs12.existsSync(resolvedPath)) {
+        output(failure(cmd, "NOT_FOUND", `Directory not found: ${resolvedPath}`, startTime));
+        return;
+      }
+      if (!fs12.statSync(resolvedPath).isDirectory()) {
+        output(failure(cmd, "NOT_A_DIRECTORY", `Not a directory: ${resolvedPath}`, startTime));
+        return;
+      }
+      const tree = buildTree(resolvedPath, 0, maxDepth);
+      output(success(cmd, { path: resolvedPath, tree, depth: maxDepth }, startTime));
+    } catch (err) {
+      output(failure(cmd, "DIR_TREE_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs12, path11;
+var init_tree = __esm({
+  "src/plugins/dir/tree.ts"() {
+    "use strict";
+    fs12 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
+    init_result();
+  }
+});
+
+// src/plugins/dir/index.ts
+var DirPlugin;
+var init_dir = __esm({
+  "src/plugins/dir/index.ts"() {
+    "use strict";
+    init_list();
+    init_create2();
+    init_delete2();
+    init_tree();
+    DirPlugin = class {
+      name = "dir";
+      version = "1.0.0";
+      description = "Directory operations (list, create, delete, tree)";
+      register(program) {
+        const dir = program.command("dir").description(this.description);
+        registerList(dir);
+        registerCreate2(dir);
+        registerDelete2(dir);
+        registerTree(dir);
+      }
+      getCommands() {
+        return [
+          {
+            name: "dir list",
+            description: "List directory entries",
+            args: [{ name: "path", description: "Directory path", required: false, type: "string" }],
+            options: [
+              { name: "--recursive", description: "List recursively", required: false, type: "boolean" },
+              { name: "--pattern", description: "Glob filter pattern", required: false, type: "string" }
+            ],
+            examples: ['moxxy-agent dir list src --recursive --pattern "*.ts"']
+          },
+          {
+            name: "dir create",
+            description: "Create a directory",
+            args: [{ name: "path", description: "Directory path", required: true, type: "string" }],
+            options: [],
+            examples: ["moxxy-agent dir create src/utils"]
+          },
+          {
+            name: "dir delete",
+            description: "Remove a directory",
+            args: [{ name: "path", description: "Directory path", required: true, type: "string" }],
+            options: [],
+            examples: ["moxxy-agent dir delete tmp"]
+          },
+          {
+            name: "dir tree",
+            description: "Display directory tree",
+            args: [{ name: "path", description: "Directory path", required: false, type: "string" }],
+            options: [
+              { name: "--depth", description: "Maximum depth", required: false, type: "number" }
+            ],
+            examples: ["moxxy-agent dir tree src --depth 2"]
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/git/init.ts
+function registerInit2(parent) {
+  parent.command("init").description("Initialize a new git repository").argument("[path]", "Directory to initialize", ".").action(async (dirPath) => {
+    const startTime = Date.now();
+    const cmd = "git init";
+    try {
+      const { stdout } = await exec("git", ["init", dirPath]);
+      output(success(cmd, { path: dirPath, message: stdout.trim() }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_INIT_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_init2 = __esm({
+  "src/plugins/git/init.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/clone.ts
+function registerClone(parent) {
+  parent.command("clone").description("Clone a git repository").argument("<url>", "Repository URL").argument("[directory]", "Target directory").option("--branch <name>", "Branch to clone").action(async (url, directory, opts) => {
+    const startTime = Date.now();
+    const cmd = "git clone";
+    try {
+      const args = ["clone"];
+      if (opts.branch) {
+        args.push("--branch", opts.branch);
+      }
+      args.push(url);
+      if (directory) {
+        args.push(directory);
+      }
+      log(`Cloning ${url}...`);
+      const { stdout, stderr } = await exec("git", args);
+      output(success(cmd, {
+        url,
+        directory: directory || url.split("/").pop()?.replace(".git", ""),
+        branch: opts.branch,
+        message: (stdout || stderr).trim()
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_CLONE_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_clone = __esm({
+  "src/plugins/git/clone.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/branch.ts
+function registerBranch(parent) {
+  parent.command("branch").description("Create or list branches").argument("[name]", "Branch name to create").option("--list", "List all branches").action(async (name, opts) => {
+    const startTime = Date.now();
+    const cmd = "git branch";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      if (opts.list || !name) {
+        const { stdout } = await exec("git", ["branch", "-a"], { cwd });
+        const branches = stdout.split("\n").filter((line) => line.trim()).map((line) => {
+          const isCurrent = line.startsWith("* ");
+          const branchName = line.replace(/^\*?\s+/, "").trim();
+          return { name: branchName, current: isCurrent };
+        });
+        output(success(cmd, { branches }, startTime));
+      } else {
+        const { stdout } = await exec("git", ["branch", name], { cwd });
+        output(success(cmd, { name, created: true, message: stdout.trim() }, startTime));
+      }
+    } catch (err) {
+      output(failure(cmd, "GIT_BRANCH_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_branch = __esm({
+  "src/plugins/git/branch.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/checkout.ts
+function registerCheckout(parent) {
+  parent.command("checkout").description("Checkout a branch").argument("<branch>", "Branch name to checkout").option("-b", "Create new branch").action(async (branch, opts) => {
+    const startTime = Date.now();
+    const cmd = "git checkout";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const args = ["checkout"];
+      if (opts.b) {
+        args.push("-b");
+      }
+      args.push(branch);
+      const { stdout, stderr } = await exec("git", args, { cwd });
+      output(success(cmd, {
+        branch,
+        created: !!opts.b,
+        message: (stderr || stdout).trim()
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_CHECKOUT_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_checkout = __esm({
+  "src/plugins/git/checkout.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/add.ts
+function registerAdd(parent) {
+  parent.command("add").description("Stage files for commit").argument("[files...]", "Files to stage").option("--all", "Stage all changes").action(async (files, opts) => {
+    const startTime = Date.now();
+    const cmd = "git add";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const args = ["add"];
+      if (opts.all) {
+        args.push("-A");
+      } else if (files.length > 0) {
+        args.push(...files);
+      } else {
+        output(failure(
+          cmd,
+          "MISSING_ARGUMENT",
+          "Provide files to stage or use --all",
+          startTime
+        ));
+        return;
+      }
+      await exec("git", args, { cwd });
+      output(success(cmd, {
+        files: opts.all ? ["(all)"] : files,
+        staged: true
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_ADD_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_add = __esm({
+  "src/plugins/git/add.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/commit.ts
+function registerCommit(parent) {
+  parent.command("commit").description("Create a git commit").requiredOption("-m <message>", "Commit message").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "git commit";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const { stdout } = await exec("git", ["commit", "-m", opts.m], { cwd });
+      const match = stdout.match(/\[.+?\s+([a-f0-9]+)\]/);
+      const hash = match?.[1] || "";
+      output(success(cmd, {
+        hash,
+        message: opts.m,
+        output: stdout.trim()
+      }, startTime));
+    } catch (err) {
+      const isNothingToCommit = err.stdout?.includes("nothing to commit") || err.stderr?.includes("nothing to commit");
+      if (isNothingToCommit) {
+        output(failure(
+          cmd,
+          "NOTHING_TO_COMMIT",
+          "Nothing to commit, working tree clean",
+          startTime
+        ));
+      } else {
+        output(failure(cmd, "GIT_COMMIT_ERROR", err.message, startTime, err.stderr));
+      }
+    }
+  });
+}
+var init_commit = __esm({
+  "src/plugins/git/commit.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/push.ts
+function registerPush(parent) {
+  parent.command("push").description("Push commits to remote").option("--set-upstream", "Set upstream tracking branch").option("--remote <name>", "Remote name", "origin").option("--branch <name>", "Branch name").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "git push";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const args = ["push"];
+      if (opts.setUpstream) {
+        args.push("--set-upstream");
+        args.push(opts.remote);
+        if (opts.branch) {
+          args.push(opts.branch);
+        } else {
+          const { stdout: stdout2 } = await exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
+          args.push(stdout2.trim());
+        }
+      }
+      const { stdout, stderr } = await exec("git", args, { cwd });
+      output(success(cmd, { message: (stderr || stdout).trim() }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_PUSH_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_push = __esm({
+  "src/plugins/git/push.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/pull.ts
+function registerPull(parent) {
+  parent.command("pull").description("Pull changes from remote").action(async () => {
+    const startTime = Date.now();
+    const cmd = "git pull";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const { stdout, stderr } = await exec("git", ["pull"], { cwd });
+      output(success(cmd, { message: (stdout || stderr).trim() }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_PULL_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_pull = __esm({
+  "src/plugins/git/pull.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/diff.ts
+function registerDiff(parent) {
+  parent.command("diff").description("Show changes").option("--staged", "Show staged changes").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "git diff";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const args = ["diff"];
+      if (opts.staged) {
+        args.push("--staged");
+      }
+      const { stdout } = await exec("git", args, { cwd });
+      output(success(cmd, { diff: stdout, staged: !!opts.staged }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_DIFF_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_diff = __esm({
+  "src/plugins/git/diff.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/status.ts
+function parsePorcelain(raw) {
+  return raw.split("\n").filter((line) => line.trim()).map((line) => {
+    const status = line.substring(0, 2).trim();
+    const filePath = line.substring(3);
+    return { status, path: filePath };
+  });
+}
+function registerStatus(parent) {
+  parent.command("status").description("Show working tree status").action(async () => {
+    const startTime = Date.now();
+    const cmd = "git status";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const { stdout } = await exec("git", ["status", "--porcelain"], { cwd });
+      const entries = parsePorcelain(stdout);
+      const isClean = entries.length === 0;
+      output(success(cmd, {
+        clean: isClean,
+        entries,
+        staged: entries.filter((e) => ["A", "M", "D", "R"].includes(e.status[0])),
+        unstaged: entries.filter((e) => e.status.length > 1 && e.status[1] !== " "),
+        untracked: entries.filter((e) => e.status === "??")
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_STATUS_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_status = __esm({
+  "src/plugins/git/status.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/log.ts
+function parseLog(raw) {
+  return raw.split("\n").filter((line) => line.trim()).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    if (spaceIdx === -1) return { hash: line, message: "" };
+    return {
+      hash: line.substring(0, spaceIdx),
+      message: line.substring(spaceIdx + 1)
+    };
+  });
+}
+function registerLog(parent) {
+  parent.command("log").description("Show commit log").option("--limit <n>", "Number of commits to show", "10").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "git log";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const limit = parseInt(opts.limit, 10) || 10;
+      const { stdout } = await exec(
+        "git",
+        ["log", `--oneline`, `-n`, String(limit)],
+        { cwd }
+      );
+      const commits = parseLog(stdout);
+      output(success(cmd, { commits, count: commits.length }, startTime));
+    } catch (err) {
+      output(failure(cmd, "GIT_LOG_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_log = __esm({
+  "src/plugins/git/log.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/git/index.ts
+var GitPlugin;
+var init_git = __esm({
+  "src/plugins/git/index.ts"() {
+    "use strict";
+    init_init2();
+    init_clone();
+    init_branch();
+    init_checkout();
+    init_add();
+    init_commit();
+    init_push();
+    init_pull();
+    init_diff();
+    init_status();
+    init_log();
+    GitPlugin = class {
+      name = "git";
+      version = "1.0.0";
+      description = "Git operations";
+      register(program) {
+        const git = program.command("git").description(this.description);
+        registerInit2(git);
+        registerClone(git);
+        registerBranch(git);
+        registerCheckout(git);
+        registerAdd(git);
+        registerCommit(git);
+        registerPush(git);
+        registerPull(git);
+        registerDiff(git);
+        registerStatus(git);
+        registerLog(git);
+      }
+      getCommands() {
+        return [
+          {
+            name: "git init",
+            description: "Initialize a new git repository",
+            args: [{ name: "path", description: "Directory path", required: false, type: "string" }],
+            options: [],
+            examples: ["moxxy-agent git init ."]
+          },
+          {
+            name: "git clone",
+            description: "Clone a git repository",
+            args: [
+              { name: "url", description: "Repository URL", required: true, type: "string" },
+              { name: "directory", description: "Target directory", required: false, type: "string" }
+            ],
+            options: [
+              { name: "--branch", description: "Branch to clone", required: false, type: "string" }
+            ],
+            examples: ["moxxy-agent git clone https://github.com/org/repo --branch main"]
+          },
+          {
+            name: "git branch",
+            description: "Create or list branches",
+            args: [{ name: "name", description: "Branch name", required: false, type: "string" }],
+            options: [
+              { name: "--list", description: "List all branches", required: false, type: "boolean" }
+            ],
+            examples: ["moxxy-agent git branch --list", "moxxy-agent git branch feat/new"]
+          },
+          {
+            name: "git checkout",
+            description: "Checkout a branch",
+            args: [{ name: "branch", description: "Branch name", required: true, type: "string" }],
+            options: [
+              { name: "-b", description: "Create new branch", required: false, type: "boolean" }
+            ],
+            examples: ["moxxy-agent git checkout main", "moxxy-agent git checkout -b feat/new"]
+          },
+          {
+            name: "git add",
+            description: "Stage files for commit",
+            args: [{ name: "files", description: "Files to stage", required: false, type: "string" }],
+            options: [
+              { name: "--all", description: "Stage all changes", required: false, type: "boolean" }
+            ],
+            examples: ["moxxy-agent git add src/main.ts", "moxxy-agent git add --all"]
+          },
+          {
+            name: "git commit",
+            description: "Create a commit",
+            args: [],
+            options: [
+              { name: "-m", description: "Commit message", required: true, type: "string" }
+            ],
+            examples: ['moxxy-agent git commit -m "feat: add feature"']
+          },
+          {
+            name: "git push",
+            description: "Push commits to remote",
+            args: [],
+            options: [
+              { name: "--set-upstream", description: "Set upstream tracking", required: false, type: "boolean" },
+              { name: "--remote", description: "Remote name", required: false, type: "string" },
+              { name: "--branch", description: "Branch name", required: false, type: "string" }
+            ],
+            examples: ["moxxy-agent git push", "moxxy-agent git push --set-upstream"]
+          },
+          {
+            name: "git pull",
+            description: "Pull changes from remote",
+            args: [],
+            options: [],
+            examples: ["moxxy-agent git pull"]
+          },
+          {
+            name: "git diff",
+            description: "Show changes",
+            args: [],
+            options: [
+              { name: "--staged", description: "Show staged changes", required: false, type: "boolean" }
+            ],
+            examples: ["moxxy-agent git diff", "moxxy-agent git diff --staged"]
+          },
+          {
+            name: "git status",
+            description: "Show working tree status",
+            args: [],
+            options: [],
+            examples: ["moxxy-agent git status"]
+          },
+          {
+            name: "git log",
+            description: "Show commit log",
+            args: [],
+            options: [
+              { name: "--limit", description: "Number of commits", required: false, type: "number" }
+            ],
+            examples: ["moxxy-agent git log --limit 20"]
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/search/code.ts
+function parseGrepOutput(raw) {
+  return raw.split("\n").filter((line) => line.trim()).map((line) => {
+    const firstColon = line.indexOf(":");
+    const secondColon = line.indexOf(":", firstColon + 1);
+    if (firstColon === -1 || secondColon === -1) {
+      return { file: "", line: 0, content: line };
+    }
+    return {
+      file: line.substring(0, firstColon),
+      line: parseInt(line.substring(firstColon + 1, secondColon), 10) || 0,
+      content: line.substring(secondColon + 1)
+    };
+  }).filter((m) => m.file);
+}
+function registerCode(parent) {
+  parent.command("code").description("Search for code patterns").argument("<query>", "Search query (regex pattern)").option("--path <dir>", "Directory to search in", ".").option("--type <ext>", "File extension filter (e.g., ts, js)").action(async (query, opts) => {
+    const startTime = Date.now();
+    const cmd = "search code";
+    try {
+      let matches;
+      try {
+        const args = ["--line-number", "--no-heading", "--color", "never"];
+        if (opts.type) {
+          args.push("--type", opts.type);
+        }
+        args.push(query, opts.path);
+        const { stdout } = await exec("rg", args);
+        matches = parseGrepOutput(stdout);
+      } catch {
+        const args = ["-rn"];
+        if (opts.type) {
+          args.push("--include", `*.${opts.type}`);
+        }
+        args.push(query, opts.path);
+        try {
+          const { stdout } = await exec("grep", args);
+          matches = parseGrepOutput(stdout);
+        } catch (grepErr) {
+          if (grepErr.code === 1) {
+            matches = [];
+          } else {
+            throw grepErr;
+          }
+        }
+      }
+      output(success(cmd, { query, matches, count: matches.length }, startTime));
+    } catch (err) {
+      output(failure(cmd, "SEARCH_CODE_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_code = __esm({
+  "src/plugins/search/code.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/search/files.ts
+function registerFiles(parent) {
+  parent.command("files").description("Find files matching a glob pattern").argument("<pattern>", "Glob pattern").option("--path <dir>", "Directory to search in", ".").action(async (pattern, opts) => {
+    const startTime = Date.now();
+    const cmd = "search files";
+    try {
+      const searchDir = path12.resolve(opts.path);
+      const matches = await (0, import_glob2.glob)(pattern, {
+        cwd: searchDir,
+        nodir: false,
+        dot: false,
+        ignore: ["node_modules/**", ".git/**"]
+      });
+      const files = matches.map((match) => path12.join(searchDir, match));
+      output(success(cmd, { pattern, files, count: files.length }, startTime));
+    } catch (err) {
+      output(failure(cmd, "SEARCH_FILES_ERROR", err.message, startTime));
+    }
+  });
+}
+var path12, import_glob2;
+var init_files = __esm({
+  "src/plugins/search/files.ts"() {
+    "use strict";
+    path12 = __toESM(require("path"));
+    import_glob2 = require("glob");
+    init_result();
+  }
+});
+
+// src/plugins/search/docs.ts
+function registerDocs(parent) {
+  parent.command("docs").description("Search documentation files (README, markdown, comments)").argument("<query>", "Search query").option("--path <dir>", "Directory to search in", ".").action(async (query, opts) => {
+    const startTime = Date.now();
+    const cmd = "search docs";
+    try {
+      const searchDir = path13.resolve(opts.path);
+      const docPatterns = ["**/*.md", "**/README*", "**/*.txt", "**/CHANGELOG*", "**/LICENSE*"];
+      const matches = [];
+      for (const pattern of docPatterns) {
+        const files = await (0, import_glob3.glob)(pattern, {
+          cwd: searchDir,
+          nodir: true,
+          dot: false,
+          ignore: ["node_modules/**", ".git/**"]
+        });
+        for (const file of files) {
+          const fullPath = path13.join(searchDir, file);
+          try {
+            const content = fs13.readFileSync(fullPath, "utf-8");
+            const lines = content.split("\n");
+            const queryLower = query.toLowerCase();
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].toLowerCase().includes(queryLower)) {
+                matches.push({
+                  file,
+                  line: i + 1,
+                  content: lines[i].trim()
+                });
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      output(success(cmd, { query, matches, count: matches.length }, startTime));
+    } catch (err) {
+      output(failure(cmd, "SEARCH_DOCS_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs13, path13, import_glob3;
+var init_docs = __esm({
+  "src/plugins/search/docs.ts"() {
+    "use strict";
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
+    import_glob3 = require("glob");
+    init_result();
+  }
+});
+
+// src/plugins/search/index.ts
+var SearchPlugin;
+var init_search = __esm({
+  "src/plugins/search/index.ts"() {
+    "use strict";
+    init_code();
+    init_files();
+    init_docs();
+    SearchPlugin = class {
+      name = "search";
+      version = "1.0.0";
+      description = "Search operations (code, files, docs)";
+      register(program) {
+        const search = program.command("search").description(this.description);
+        registerCode(search);
+        registerFiles(search);
+        registerDocs(search);
+      }
+      getCommands() {
+        return [
+          {
+            name: "search code",
+            description: "Search for code patterns using ripgrep/grep",
+            args: [{ name: "query", description: "Regex pattern", required: true, type: "string" }],
+            options: [
+              { name: "--path", description: "Directory to search", required: false, type: "string" },
+              { name: "--type", description: "File extension filter", required: false, type: "string" }
+            ],
+            examples: ['moxxy-agent search code "TODO" --type ts']
+          },
+          {
+            name: "search files",
+            description: "Find files matching a glob pattern",
+            args: [{ name: "pattern", description: "Glob pattern", required: true, type: "string" }],
+            options: [
+              { name: "--path", description: "Directory to search", required: false, type: "string" }
+            ],
+            examples: ['moxxy-agent search files "**/*.ts" --path src']
+          },
+          {
+            name: "search docs",
+            description: "Search documentation files",
+            args: [{ name: "query", description: "Search query", required: true, type: "string" }],
+            options: [
+              { name: "--path", description: "Directory to search", required: false, type: "string" }
+            ],
+            examples: ['moxxy-agent search docs "installation"']
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/pr/create.ts
+function registerCreate3(parent) {
+  parent.command("create").description("Create a pull request").requiredOption("--title <text>", "PR title").option("--body <text>", "PR body/description").option("--base <branch>", "Base branch").action(async (opts) => {
+    const startTime = Date.now();
+    const cmd = "pr create";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const args = ["pr", "create", "--title", opts.title];
+      if (opts.body) {
+        args.push("--body", opts.body);
+      }
+      if (opts.base) {
+        args.push("--base", opts.base);
+      }
+      log(`Creating PR: ${opts.title}`);
+      const { stdout } = await exec("gh", args, { cwd });
+      const url = stdout.trim();
+      output(success(cmd, {
+        url,
+        title: opts.title,
+        base: opts.base
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "PR_CREATE_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_create3 = __esm({
+  "src/plugins/pr/create.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/pr/comment.ts
+function registerComment(parent) {
+  parent.command("comment").description("Add a comment to a pull request").argument("<number>", "PR number").requiredOption("--body <text>", "Comment body").action(async (number, opts) => {
+    const startTime = Date.now();
+    const cmd = "pr comment";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const { stdout } = await exec(
+        "gh",
+        ["pr", "comment", number, "--body", opts.body],
+        { cwd }
+      );
+      output(success(cmd, {
+        prNumber: parseInt(number, 10),
+        commented: true,
+        url: stdout.trim()
+      }, startTime));
+    } catch (err) {
+      output(failure(cmd, "PR_COMMENT_ERROR", err.message, startTime, err.stderr));
+    }
+  });
+}
+var init_comment = __esm({
+  "src/plugins/pr/comment.ts"() {
+    "use strict";
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/pr/index.ts
+var PRPlugin;
+var init_pr = __esm({
+  "src/plugins/pr/index.ts"() {
+    "use strict";
+    init_create3();
+    init_comment();
+    PRPlugin = class {
+      name = "pr";
+      version = "1.0.0";
+      description = "Pull request operations (create, comment)";
+      register(program) {
+        const pr = program.command("pr").description(this.description);
+        registerCreate3(pr);
+        registerComment(pr);
+      }
+      getCommands() {
+        return [
+          {
+            name: "pr create",
+            description: "Create a pull request using gh CLI",
+            args: [],
+            options: [
+              { name: "--title", description: "PR title", required: true, type: "string" },
+              { name: "--body", description: "PR description", required: false, type: "string" },
+              { name: "--base", description: "Base branch", required: false, type: "string" }
+            ],
+            examples: ['moxxy-agent pr create --title "feat: add feature" --base main']
+          },
+          {
+            name: "pr comment",
+            description: "Comment on a pull request",
+            args: [{ name: "number", description: "PR number", required: true, type: "number" }],
+            options: [
+              { name: "--body", description: "Comment text", required: true, type: "string" }
+            ],
+            examples: ['moxxy-agent pr comment 42 --body "LGTM"']
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/plugins/workflow/run.ts
+async function executeStep(step, cwd) {
+  const args = [step.plugin, step.command];
+  for (const [key, value] of Object.entries(step.args)) {
+    if (typeof value === "boolean") {
+      if (value) args.push(`--${key}`);
+    } else {
+      args.push(`--${key}`, String(value));
+    }
+  }
+  const startTime = Date.now();
+  try {
+    const { stdout } = await exec("moxxy-agent", args, { cwd });
+    const result = JSON.parse(stdout.trim());
+    return { stepId: step.id, result, skipped: false };
+  } catch (err) {
+    return {
+      stepId: step.id,
+      result: {
+        success: false,
+        command: `${step.plugin} ${step.command}`,
+        error: { code: "STEP_FAILED", message: err.message },
+        duration_ms: Date.now() - startTime
+      },
+      skipped: false
+    };
+  }
+}
+function topologicalSort(steps) {
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  const stepsById = new Map(steps.map((s) => [s.id, s]));
+  function visit(step) {
+    if (visited.has(step.id)) return;
+    visited.add(step.id);
+    for (const depId of step.dependsOn || []) {
+      const dep = stepsById.get(depId);
+      if (dep) visit(dep);
+    }
+    sorted.push(step);
+  }
+  for (const step of steps) {
+    visit(step);
+  }
+  return sorted;
+}
+function registerRun(parent) {
+  parent.command("run").description("Run a workflow from a JSON file").argument("<workflow-file>", "Path to workflow JSON file").action(async (workflowFile) => {
+    const startTime = Date.now();
+    const cmd = "workflow run";
+    const cwd = parent.optsWithGlobals().cwd || process.cwd();
+    try {
+      const filePath = path14.resolve(workflowFile);
+      if (!fs14.existsSync(filePath)) {
+        output(failure(cmd, "NOT_FOUND", `Workflow file not found: ${filePath}`, startTime));
+        return;
+      }
+      const raw = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+      const workflow = import_types.workflowSchema.parse(raw);
+      log(`Running workflow: ${workflow.name}`);
+      const sortedSteps = topologicalSort(workflow.steps);
+      const stepResults = [];
+      const completedSteps = /* @__PURE__ */ new Set();
+      let allSuccess = true;
+      for (const step of sortedSteps) {
+        const depsFailed = (step.dependsOn || []).some((depId) => {
+          const depResult = stepResults.find((r) => r.stepId === depId);
+          return depResult && !depResult.result.success;
+        });
+        if (depsFailed) {
+          if (step.optional) {
+            stepResults.push({
+              stepId: step.id,
+              result: {
+                success: false,
+                command: `${step.plugin} ${step.command}`,
+                error: {
+                  code: "SKIPPED",
+                  message: "Skipped due to failed dependency"
+                },
+                duration_ms: 0
+              },
+              skipped: true
+            });
+            continue;
+          }
+          allSuccess = false;
+          stepResults.push({
+            stepId: step.id,
+            result: {
+              success: false,
+              command: `${step.plugin} ${step.command}`,
+              error: {
+                code: "DEP_FAILED",
+                message: "Dependency failed, step not executed"
+              },
+              duration_ms: 0
+            },
+            skipped: true
+          });
+          continue;
+        }
+        log(`  Step: ${step.id} - ${step.description}`);
+        const result = await executeStep(step, cwd);
+        stepResults.push(result);
+        if (result.result.success) {
+          completedSteps.add(step.id);
+        } else {
+          allSuccess = false;
+          if (!step.optional) {
+            log(`  Step ${step.id} failed, stopping workflow`);
+            for (const remaining of sortedSteps) {
+              if (!stepResults.find((r) => r.stepId === remaining.id)) {
+                stepResults.push({
+                  stepId: remaining.id,
+                  result: {
+                    success: false,
+                    command: `${remaining.plugin} ${remaining.command}`,
+                    error: {
+                      code: "SKIPPED",
+                      message: "Skipped due to earlier failure"
+                    },
+                    duration_ms: 0
+                  },
+                  skipped: true
+                });
+              }
+            }
+            break;
+          }
+        }
+      }
+      const workflowResult = {
+        workflowId: workflow.id,
+        success: allSuccess,
+        stepResults,
+        duration_ms: Date.now() - startTime
+      };
+      output(success(cmd, workflowResult, startTime));
+    } catch (err) {
+      output(failure(cmd, "WORKFLOW_RUN_ERROR", err.message, startTime));
+    }
+  });
+}
+var fs14, path14, import_types;
+var init_run = __esm({
+  "src/plugins/workflow/run.ts"() {
+    "use strict";
+    fs14 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
+    import_types = require("@moxxy/types");
+    init_exec();
+    init_result();
+  }
+});
+
+// src/plugins/workflow/status.ts
+function registerStatus2(parent) {
+  parent.command("status").description("Show status of running workflows").action(async () => {
+    const startTime = Date.now();
+    const cmd = "workflow status";
+    output(success(cmd, {
+      running: [],
+      message: "No workflows currently running"
+    }, startTime));
+  });
+}
+var init_status2 = __esm({
+  "src/plugins/workflow/status.ts"() {
+    "use strict";
+    init_result();
+  }
+});
+
+// src/plugins/workflow/index.ts
+var WorkflowPlugin;
+var init_workflow = __esm({
+  "src/plugins/workflow/index.ts"() {
+    "use strict";
+    init_run();
+    init_status2();
+    WorkflowPlugin = class {
+      name = "workflow";
+      version = "1.0.0";
+      description = "Workflow orchestration (run, status)";
+      register(program) {
+        const workflow = program.command("workflow").description(this.description);
+        registerRun(workflow);
+        registerStatus2(workflow);
+      }
+      getCommands() {
+        return [
+          {
+            name: "workflow run",
+            description: "Run a workflow from a JSON definition file",
+            args: [
+              { name: "workflow-file", description: "Path to workflow JSON", required: true, type: "string" }
+            ],
+            options: [],
+            examples: ["moxxy-agent workflow run deploy.json"]
+          },
+          {
+            name: "workflow status",
+            description: "Show status of running workflows",
+            args: [],
+            options: [],
+            examples: ["moxxy-agent workflow status"]
+          }
+        ];
+      }
+    };
+  }
+});
+
+// src/core/plugin-loader.ts
+function loadBuiltinPlugins(registry) {
+  registry.register(new WorkspacePlugin());
+  registry.register(new FilePlugin());
+  registry.register(new DirPlugin());
+  registry.register(new GitPlugin());
+  registry.register(new SearchPlugin());
+  registry.register(new PRPlugin());
+  registry.register(new WorkflowPlugin());
+}
+var init_plugin_loader = __esm({
+  "src/core/plugin-loader.ts"() {
+    "use strict";
+    init_workspace();
+    init_file();
+    init_dir();
+    init_git();
+    init_search();
+    init_pr();
+    init_workflow();
+  }
+});
+
+// src/help/index.ts
+function showHelp(registry) {
+  log("");
+  log("moxxy-agent - Agent-facing CLI tool for structured operations");
+  log("");
+  log("Usage: moxxy-agent [options] <plugin> <command> [args...]");
+  log("");
+  log("Global Options:");
+  log("  --cwd <path>     Set working directory");
+  log("  --verbose         Enable verbose logging");
+  log("  -h, --help        Show help");
+  log("  -V, --version     Show version");
+  log("");
+  log("Plugins:");
+  for (const plugin of registry.getAll()) {
+    log(`  ${plugin.name.padEnd(15)} ${plugin.description}`);
+    for (const cmd of plugin.getCommands()) {
+      log(`    ${cmd.name.padEnd(25)} ${cmd.description}`);
+    }
+    log("");
+  }
+}
+var init_help = __esm({
+  "src/help/index.ts"() {
+    "use strict";
+    init_result();
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  createProgram: () => createProgram
+});
+function createProgram() {
+  const program = new import_commander.Command();
+  const registry = new PluginRegistry();
+  program.name("moxxy-agent").description("Agent-facing CLI tool for structured operations").version("1.0.0").option("--cwd <path>", "Set working directory").option("--verbose", "Enable verbose logging");
+  loadBuiltinPlugins(registry);
+  for (const plugin of registry.getAll()) {
+    plugin.register(program);
+  }
+  program.on("--help", () => {
+    showHelp(registry);
+  });
+  return program;
+}
+var import_commander;
+var init_cli = __esm({
+  "src/cli.ts"() {
+    "use strict";
+    import_commander = require("commander");
+    init_plugin_registry();
+    init_plugin_loader();
+    init_help();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PluginRegistry: () => PluginRegistry,
+  createProgram: () => createProgram,
+  detectWorkspace: () => detectWorkspace,
+  failure: () => failure,
+  getContext: () => getContext,
+  log: () => log,
+  output: () => output,
+  run: () => run,
+  success: () => success
+});
+module.exports = __toCommonJS(index_exports);
+init_cli();
+init_plugin_registry();
+init_result();
+init_context();
+async function run() {
+  const { createProgram: createProgram2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  const program = createProgram2();
+  await program.parseAsync(process.argv);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginRegistry,
+  createProgram,
+  detectWorkspace,
+  failure,
+  getContext,
+  log,
+  output,
+  run,
+  success
+});