@moxxy/agent-cli 0.0.3 → 0.0.5

package/dist/chunk-ZTFAXFQJ.mjs

@@ -0,0 +1,2108 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/core/plugin-registry.ts
+var 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
+import { execFile } from "child_process";
+function exec(command, args, options) {
+  return new Promise((resolve14, reject) => {
+    execFile(
+      command,
+      args,
+      { ...options, maxBuffer: 10 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(Object.assign(error, { stdout, stderr }));
+        } else {
+          resolve14({ stdout, stderr });
+        }
+      }
+    );
+  });
+}
+
+// src/core/context.ts
+import * as fs from "fs";
+import * as path from "path";
+var currentContext = null;
+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;
+}
+
+// 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");
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// src/plugins/workspace/clean.ts
+import * as fs2 from "fs";
+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));
+    }
+  });
+}
+
+// src/plugins/workspace/index.ts
+var 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
+import * as fs3 from "fs";
+import * as path2 from "path";
+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);
+  });
+}
+
+// src/plugins/file/read.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/file/update.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+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);
+  });
+}
+
+// src/plugins/file/delete.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/file/move.ts
+import * as fs7 from "fs";
+import * as path6 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/file/patch.ts
+import * as fs8 from "fs";
+import * as path7 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/file/index.ts
+var 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
+import * as fs9 from "fs";
+import * as path8 from "path";
+import { glob } from "glob";
+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 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));
+    }
+  });
+}
+
+// src/plugins/dir/create.ts
+import * as fs10 from "fs";
+import * as path9 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/dir/delete.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/dir/tree.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+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));
+    }
+  });
+}
+
+// src/plugins/dir/index.ts
+var 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+      }
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// src/plugins/git/index.ts
+var 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));
+    }
+  });
+}
+
+// src/plugins/search/files.ts
+import * as path12 from "path";
+import { glob as glob2 } from "glob";
+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 glob2(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));
+    }
+  });
+}
+
+// src/plugins/search/docs.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+import { glob as glob3 } from "glob";
+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 glob3(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));
+    }
+  });
+}
+
+// src/plugins/search/index.ts
+var 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));
+    }
+  });
+}
+
+// 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));
+    }
+  });
+}
+
+// src/plugins/pr/index.ts
+var 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
+import * as fs14 from "fs";
+import * as path14 from "path";
+
+// ../types/dist/index.mjs
+import { z as z2 } from "zod";
+import { z } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z10 } from "zod";
+import { z as z9 } from "zod";
+import { z as z11 } from "zod";
+var uuidSchema = z.string().uuid();
+var timestampSchema = z.number().int().positive();
+var paginationSchema = z.object({
+  page: z.number().int().positive().optional().default(1),
+  limit: z.number().int().positive().max(100).optional().default(20),
+  orderBy: z.string().optional(),
+  order: z.enum(["asc", "desc"]).optional().default("desc")
+});
+var activityTypeSchema = z2.enum([
+  "created",
+  "assigned",
+  "status_change",
+  "comment",
+  "commit",
+  "pr_created",
+  "pr_merged",
+  "pr_closed"
+]);
+var taskActivitySchema = z2.object({
+  id: uuidSchema,
+  taskId: uuidSchema,
+  agentId: uuidSchema.nullable(),
+  activityType: activityTypeSchema,
+  description: z2.string().max(500),
+  metadata: z2.record(z2.any()),
+  createdAt: timestampSchema
+});
+var createActivitySchema = z2.object({
+  taskId: uuidSchema,
+  agentId: uuidSchema.nullable().optional(),
+  activityType: activityTypeSchema,
+  description: z2.string().max(500),
+  metadata: z2.record(z2.any()).optional().default({})
+});
+var agentStatusSchema = z3.enum(["available", "busy", "offline"]);
+var agentTypeSchema = z3.enum([
+  "developer",
+  "prd",
+  "code-review",
+  "orchestrator",
+  "custom"
+]);
+var agentCapabilitySchema = z3.enum([
+  "frontend",
+  "backend",
+  "fullstack",
+  "devops",
+  "testing",
+  "documentation"
+]);
+var agentIdentitySchema = z3.object({
+  /** Display name for the agent (persona name) */
+  displayName: z3.string().max(100).optional(),
+  /** Theme/persona description */
+  theme: z3.string().max(500).optional(),
+  /** Emoji representation */
+  emoji: z3.string().max(10).optional(),
+  /** Avatar path or URL */
+  avatar: z3.string().url().optional().or(z3.string().max(0)),
+  /** Custom system prompt */
+  systemPrompt: z3.string().max(1e4).optional()
+});
+var agentModelConfigSchema = z3.object({
+  /** Primary model (provider/model format) */
+  primary: z3.string().optional(),
+  /** Fallback models in order of preference */
+  fallbacks: z3.array(z3.string()).optional()
+});
+var agentSchema = z3.object({
+  id: uuidSchema,
+  name: z3.string().min(1).max(100),
+  moltAgentId: z3.string().min(1),
+  githubToken: z3.string().min(1),
+  githubUsername: z3.string().min(1),
+  workspace: z3.string().min(1),
+  capabilities: z3.array(agentCapabilitySchema),
+  status: agentStatusSchema,
+  currentTaskId: uuidSchema.nullable(),
+  agentType: agentTypeSchema.optional(),
+  identity: agentIdentitySchema.optional(),
+  modelConfig: agentModelConfigSchema.optional(),
+  projectId: uuidSchema.optional(),
+  lastSyncAt: timestampSchema,
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var createAgentSchema = z3.object({
+  name: z3.string().min(1).max(100),
+  githubToken: z3.string().min(1),
+  githubUsername: z3.string().min(1),
+  capabilities: z3.array(agentCapabilitySchema).min(1),
+  workspace: z3.string().min(1),
+  /** Agent type for specialized behaviors */
+  agentType: agentTypeSchema.optional(),
+  /** Agent identity/persona configuration */
+  identity: agentIdentitySchema.optional()
+});
+var updateAgentSchema = z3.object({
+  name: z3.string().min(1).max(100).optional(),
+  status: agentStatusSchema.optional(),
+  workspace: z3.string().min(1).optional(),
+  capabilities: z3.array(agentCapabilitySchema).optional(),
+  /** Agent type for specialized behaviors */
+  agentType: agentTypeSchema.optional(),
+  /** Agent identity/persona configuration */
+  identity: agentIdentitySchema.optional(),
+  /** Model configuration update */
+  modelConfig: agentModelConfigSchema.optional(),
+  /** Update GitHub PAT token */
+  githubToken: z3.string().min(1).optional(),
+  /** Update GitHub username */
+  githubUsername: z3.string().min(1).optional()
+});
+var taskFiltersSchema = z4.object({
+  projectId: z4.string().uuid().optional(),
+  status: z4.string().optional(),
+  type: z4.string().optional(),
+  priority: z4.string().optional(),
+  assignedAgentId: z4.string().uuid().optional()
+});
+var INTEGRATION_TYPES = ["slack", "discord", "email", "github"];
+var NOTIFICATION_EVENTS = [
+  "task:created",
+  "task:completed",
+  "task:failed",
+  "task:assigned",
+  "task:status_changed",
+  "agent:status_changed",
+  "pr:created",
+  "pr:merged"
+];
+var createIntegrationSchema = z5.object({
+  type: z5.enum(INTEGRATION_TYPES),
+  name: z5.string().min(1).max(100),
+  enabled: z5.boolean().optional().default(false),
+  config: z5.record(z5.unknown()),
+  enabledEvents: z5.array(z5.enum(NOTIFICATION_EVENTS)).optional().default([])
+});
+var updateIntegrationSchema = z5.object({
+  name: z5.string().min(1).max(100).optional(),
+  enabled: z5.boolean().optional(),
+  config: z5.record(z5.unknown()).optional(),
+  enabledEvents: z5.array(z5.enum(NOTIFICATION_EVENTS)).optional()
+});
+var projectStatusSchema = z6.enum(["active", "archived", "paused"]);
+var workflowModeSchema = z6.enum(["manual", "automatic"]);
+var validationSettingsSchema = z6.object({
+  runInstall: z6.boolean().optional(),
+  runTests: z6.boolean().optional(),
+  runBuild: z6.boolean().optional(),
+  runLint: z6.boolean().optional(),
+  blockOnFailure: z6.boolean().optional(),
+  installCommand: z6.string().max(500).optional(),
+  testCommand: z6.string().max(500).optional(),
+  buildCommand: z6.string().max(500).optional(),
+  lintCommand: z6.string().max(500).optional(),
+  maxRetries: z6.number().int().min(0).max(100).optional(),
+  preferSameAgent: z6.boolean().optional(),
+  timeout: z6.number().int().min(1e3).max(36e5).optional()
+  // 1s to 1h
+});
+var workflowSettingsSchema = z6.object({
+  mode: workflowModeSchema,
+  previewBranch: z6.string().min(1).max(100),
+  autoMerge: z6.boolean().optional(),
+  validation: validationSettingsSchema.optional()
+});
+var prdStatusSchema = z6.enum([
+  "idle",
+  "generating",
+  "completed",
+  "failed",
+  "tasks_generating",
+  "tasks_completed",
+  "tasks_failed"
+]);
+var prdTemplateSchema = z6.enum(["mobile", "web", "api", "feature", "data-pipeline"]);
+var prdTaskSchema = z6.object({
+  id: z6.string(),
+  prdId: z6.string(),
+  step: z6.number(),
+  title: z6.string(),
+  description: z6.string(),
+  status: z6.enum(["todo", "in_progress", "done", "blocked"]),
+  priority: z6.enum(["P0", "P1", "P2"]),
+  estimatedHours: z6.number().optional(),
+  phase: z6.enum(["discovery", "design", "development", "testing", "deployment"]).optional(),
+  createdAt: z6.string(),
+  updatedAt: z6.string(),
+  completedAt: z6.string().optional()
+});
+var projectSchema = z6.object({
+  id: uuidSchema,
+  name: z6.string().min(1).max(100),
+  description: z6.string().max(500),
+  githubRepoUrl: z6.string().url(),
+  githubOwner: z6.string().min(1),
+  githubRepo: z6.string().min(1),
+  status: projectStatusSchema,
+  defaultBranch: z6.string().min(1).max(100).optional(),
+  workflowSettings: workflowSettingsSchema.optional(),
+  assignedAgentIds: z6.array(uuidSchema).optional(),
+  prd: z6.string().optional(),
+  prdGeneratedAt: timestampSchema.optional(),
+  prdStatus: prdStatusSchema.optional(),
+  prdError: z6.string().optional(),
+  prdTemplate: prdTemplateSchema.optional(),
+  prdTasks: z6.array(prdTaskSchema).optional(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema
+});
+var generatePRDInputSchema = z6.object({
+  template: prdTemplateSchema.optional().default("feature")
+});
+var importPRDTasksInputSchema = z6.object({
+  tasks: z6.array(
+    z6.object({
+      title: z6.string(),
+      description: z6.string(),
+      priority: z6.enum(["P0", "P1", "P2"]).optional(),
+      estimatedHours: z6.number().optional(),
+      phase: z6.string().optional()
+    })
+  ),
+  taskType: z6.enum(["feature", "bug", "research", "refactor", "documentation"])
+});
+var updatePRDInputSchema = z6.object({
+  prd: z6.string()
+});
+var createProjectSchema = z6.object({
+  name: z6.string().min(1).max(100),
+  description: z6.string().max(500),
+  githubRepoUrl: z6.string().url()
+});
+var updateProjectSchema = z6.object({
+  name: z6.string().min(1).max(100).optional(),
+  description: z6.string().max(500).optional(),
+  status: projectStatusSchema.optional(),
+  defaultBranch: z6.string().min(1).max(100).optional(),
+  workflowSettings: workflowSettingsSchema.optional()
+});
+var taskStatusSchema = z7.enum(["todo", "in_progress", "review", "done", "blocked"]);
+var taskTypeSchema = z7.enum(["feature", "bug", "research", "refactor", "documentation"]);
+var taskPrioritySchema = z7.enum(["low", "medium", "high", "urgent"]);
+var agentNoteTypeSchema = z7.enum([
+  "progress",
+  "summary",
+  "error",
+  "completion",
+  "feedback"
+]);
+var agentNoteSchema = z7.object({
+  id: uuidSchema,
+  agentId: uuidSchema,
+  agentName: z7.string(),
+  content: z7.string(),
+  type: agentNoteTypeSchema,
+  createdAt: timestampSchema,
+  isUserFeedback: z7.boolean().optional()
+});
+var taskSchema = z7.object({
+  id: uuidSchema,
+  projectId: uuidSchema,
+  title: z7.string().min(1).max(200),
+  description: z7.string().max(2e3),
+  type: taskTypeSchema,
+  status: taskStatusSchema,
+  priority: taskPrioritySchema,
+  position: z7.number().int().default(0),
+  // Manual ordering within status
+  assignedAgentId: uuidSchema.nullable(),
+  autoAssign: z7.boolean().default(true),
+  // Whether agents should auto-pick this task
+  agentNotes: z7.array(agentNoteSchema).default([]),
+  githubIssueNumber: z7.number().int().positive().nullable(),
+  githubPrNumber: z7.number().int().positive().nullable(),
+  metadata: z7.record(z7.any()),
+  blockedBy: z7.array(uuidSchema).default([]),
+  // Task IDs that must be completed before this task
+  blocking: z7.array(uuidSchema).default([]),
+  // Task IDs that depend on this task
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  completedAt: timestampSchema.nullable()
+});
+var createTaskSchema = z7.object({
+  projectId: uuidSchema,
+  title: z7.string().min(1).max(200),
+  description: z7.string().max(2e3),
+  type: taskTypeSchema,
+  priority: taskPrioritySchema.optional().default("medium"),
+  assignedAgentId: uuidSchema.optional(),
+  // Optional agent to assign on creation
+  autoAssign: z7.boolean().optional().default(true),
+  // Auto-assign to agents (default: true)
+  blockedBy: z7.array(uuidSchema).optional()
+  // Task IDs that must be completed before this task
+});
+var updateTaskSchema = z7.object({
+  title: z7.string().min(1).max(200).optional(),
+  description: z7.string().max(2e3).optional(),
+  type: taskTypeSchema.optional(),
+  status: taskStatusSchema.optional(),
+  priority: taskPrioritySchema.optional(),
+  position: z7.number().int().optional(),
+  // Manual ordering within status
+  assignedAgentId: uuidSchema.nullable().optional(),
+  autoAssign: z7.boolean().optional(),
+  // Whether agents should auto-pick this task
+  githubIssueNumber: z7.number().int().positive().nullable().optional(),
+  githubPrNumber: z7.number().int().positive().nullable().optional(),
+  metadata: z7.record(z7.any()).optional(),
+  blockedBy: z7.array(uuidSchema).optional()
+  // Task IDs that must be completed before this task
+});
+var clientEventTypeSchema = z8.enum([
+  "subscribe:project",
+  "unsubscribe:project",
+  "subscribe:task",
+  "unsubscribe:task"
+]);
+var serverEventTypeSchema = z8.enum([
+  "task:created",
+  "task:updated",
+  "task:status_changed",
+  "task:assigned",
+  "task:progress",
+  "task:stream",
+  "task:note_added",
+  "task:execution_cancelled",
+  "task:dependencies_updated",
+  "tasks:reordered",
+  "agent:created",
+  "agent:updated",
+  "agent:status_changed",
+  "agent:log",
+  "activity:created",
+  "project:updated",
+  "project:prd_status_changed",
+  "error"
+]);
+var githubIssuePayloadSchema = z9.object({
+  action: z9.string(),
+  issueNumber: z9.number().int().positive(),
+  title: z9.string(),
+  body: z9.string().nullable(),
+  labels: z9.array(z9.string()),
+  author: z9.string(),
+  repo: z9.object({
+    owner: z9.string(),
+    name: z9.string(),
+    fullName: z9.string(),
+    defaultBranch: z9.string(),
+    cloneUrl: z9.string()
+  }),
+  url: z9.string().url(),
+  createdAt: z9.string()
+});
+var ISSUE_TYPES = ["feature", "bug", "refactor", "docs", "test", "chore"];
+var ISSUE_PRIORITIES = ["low", "medium", "high", "urgent"];
+var ISSUE_COMPLEXITIES = ["trivial", "small", "medium", "large", "epic"];
+var issueClassificationSchema = z9.object({
+  type: z9.enum(ISSUE_TYPES),
+  priority: z9.enum(ISSUE_PRIORITIES),
+  complexity: z9.enum(ISSUE_COMPLEXITIES),
+  confidence: z9.number().min(0).max(1),
+  reasoning: z9.string()
+});
+var PIPELINE_STAGES = [
+  "triage",
+  "research",
+  "inspect",
+  "plan",
+  "implement"
+];
+var PIPELINE_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var pipelineStageResultSchema = z9.object({
+  stage: z9.enum(PIPELINE_STAGES),
+  status: z9.enum(PIPELINE_STATUSES),
+  output: z9.unknown().optional(),
+  error: z9.string().optional(),
+  duration_ms: z9.number().optional()
+});
+var pipelineRunSchema = z9.object({
+  id: z9.string(),
+  issueNumber: z9.number().int().positive(),
+  repo: z9.object({
+    owner: z9.string(),
+    name: z9.string()
+  }),
+  stages: z9.array(pipelineStageResultSchema),
+  status: z9.enum(PIPELINE_STATUSES),
+  branchName: z9.string().optional(),
+  prNumber: z9.number().int().positive().optional(),
+  classification: issueClassificationSchema.optional(),
+  createdAt: z9.number(),
+  updatedAt: z9.number()
+});
+var gatewayConfigSchema = z10.object({
+  url: z10.string().url(),
+  authToken: z10.string().optional(),
+  deviceId: z10.string().optional(),
+  devicePrivateKey: z10.string().optional()
+});
+var githubAuthConfigSchema = z10.object({
+  token: z10.string(),
+  webhookSecret: z10.string().optional(),
+  appId: z10.string().optional(),
+  privateKey: z10.string().optional()
+});
+var webhookServerConfigSchema = z10.object({
+  port: z10.number().int().positive().default(3456),
+  host: z10.string().default("0.0.0.0"),
+  path: z10.string().default("/webhook/github")
+});
+var watchedRepoSchema = z10.object({
+  owner: z10.string(),
+  repo: z10.string(),
+  defaultBranch: z10.string().default("main"),
+  enabledEvents: z10.array(z10.string()).default(["issues.opened", "issues.labeled"]),
+  labels: z10.array(z10.string()).optional()
+});
+var agentRunConfigSchema = z10.object({
+  moltAgentId: z10.string().optional(),
+  maxConcurrentTasks: z10.number().int().positive().default(1)
+});
+var sdkProviderSchema = z10.enum(["molt", "claude"]).default("molt");
+var claudeConfigSchema = z10.object({
+  apiKey: z10.string().optional(),
+  cliPath: z10.string().default("claude"),
+  model: z10.string().default("claude-sonnet-4-5"),
+  timeout: z10.number().int().positive().default(3e5),
+  permissionMode: z10.string().default("default")
+});
+var pipelineConfigSchema = z10.object({
+  enabledStages: z10.array(z10.enum(PIPELINE_STAGES)).default(["triage", "research", "inspect", "plan", "implement"])
+});
+var moxxyConfigSchema = z10.object({
+  version: z10.number().int().positive().default(1),
+  sdk: sdkProviderSchema,
+  gateway: gatewayConfigSchema.optional(),
+  github: githubAuthConfigSchema,
+  webhook: webhookServerConfigSchema.optional(),
+  repos: z10.array(watchedRepoSchema).default([]),
+  agent: agentRunConfigSchema.optional(),
+  pipeline: pipelineConfigSchema.optional(),
+  claude: claudeConfigSchema.optional()
+});
+var agentCommandResultSchema = z11.object({
+  success: z11.boolean(),
+  command: z11.string(),
+  data: z11.unknown().optional(),
+  error: z11.object({
+    code: z11.string(),
+    message: z11.string(),
+    details: z11.string().optional()
+  }).optional(),
+  duration_ms: z11.number()
+});
+var argDefSchema = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  required: z11.boolean().default(false),
+  type: z11.enum(["string", "number", "boolean"]).default("string")
+});
+var optionDefSchema = z11.object({
+  name: z11.string(),
+  short: z11.string().optional(),
+  description: z11.string(),
+  required: z11.boolean().default(false),
+  type: z11.enum(["string", "number", "boolean"]).default("string"),
+  defaultValue: z11.unknown().optional()
+});
+var agentCLICommandDefSchema = z11.object({
+  name: z11.string(),
+  description: z11.string(),
+  args: z11.array(argDefSchema),
+  options: z11.array(optionDefSchema),
+  examples: z11.array(z11.string())
+});
+var workflowStepSchema = z11.object({
+  id: z11.string(),
+  plugin: z11.string(),
+  command: z11.string(),
+  args: z11.record(z11.unknown()),
+  description: z11.string(),
+  dependsOn: z11.array(z11.string()).optional(),
+  optional: z11.boolean().optional()
+});
+var workflowSchema = z11.object({
+  id: z11.string(),
+  name: z11.string(),
+  description: z11.string(),
+  steps: z11.array(workflowStepSchema),
+  context: z11.record(z11.unknown())
+});
+var workflowStepResultSchema = z11.object({
+  stepId: z11.string(),
+  result: agentCommandResultSchema,
+  skipped: z11.boolean().default(false)
+});
+var workflowResultSchema = z11.object({
+  workflowId: z11.string(),
+  success: z11.boolean(),
+  stepResults: z11.array(workflowStepResultSchema),
+  duration_ms: z11.number()
+});
+
+// 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 = 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));
+    }
+  });
+}
+
+// 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));
+  });
+}
+
+// src/plugins/workflow/index.ts
+var 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());
+}
+
+// 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("");
+  }
+}
+
+// src/cli.ts
+function createProgram() {
+  const program = new 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;
+}
+
+export {
+  PluginRegistry,
+  detectWorkspace,
+  getContext,
+  success,
+  failure,
+  output,
+  log,
+  createProgram
+};