@polterware/polter 0.2.4 → 0.3.1

package/dist/mcp.js

@@ -1,23 +1,30 @@
 #!/usr/bin/env node
-import "./chunk-EB76TTZL.js";
+import "./chunk-AGVTFYXU.js";
 import {
   __export,
   allCommands,
   applyActions,
   deletePipeline,
+  detectPkgManager,
   executePipeline,
   findPipelineByName,
+  generateProcessId,
   getAllPipelines,
   getCommandById,
   getCommandsByTool,
   getCurrentStatus,
+  getProcessOutput,
   getToolInfo,
+  listProcesses,
   parsePolterYaml,
   planChanges,
+  resolvePkgArgs,
   resolveToolCommand,
   runCommand,
-  savePipeline
-} from "./chunk-2B2UWOVQ.js";
+  savePipeline,
+  startProcess,
+  stopProcess
+} from "./chunk-7MIUDIAI.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -13793,7 +13800,9 @@ config(en_default());
 
 // src/mcp.ts
 import crypto from "crypto";
-var TOOL_IDS = ["supabase", "gh", "vercel", "git"];
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var TOOL_IDS = ["supabase", "gh", "vercel", "git", "pkg"];
 var server = new McpServer({
   name: "polter",
   version: "0.1.0"
@@ -13801,7 +13810,7 @@ var server = new McpServer({
 server.tool(
   "polter_list_commands",
   "List available CLI commands across Supabase, GitHub, Vercel, and Git. Optionally filter by tool.",
-  { tool: external_exports.enum(["supabase", "gh", "vercel", "git"]).optional() },
+  { tool: external_exports.enum(["supabase", "gh", "vercel", "git", "pkg"]).optional() },
   async ({ tool }) => {
     const commands = tool ? getCommandsByTool(tool) : allCommands;
     const result = commands.map((cmd) => ({
@@ -13835,14 +13844,29 @@ server.tool(
         isError: true
       };
     }
-    const resolved = resolveToolCommand(cmdDef.tool);
-    const allArgs = [...cmdDef.base, ...args ?? [], ...flags ?? []];
+    const cwd = process.cwd();
+    const resolved = resolveToolCommand(cmdDef.tool, cwd);
+    let baseArgs;
+    if (cmdDef.tool === "pkg") {
+      try {
+        const translated = resolvePkgArgs(cmdDef.base, cwd);
+        baseArgs = translated.args;
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+          isError: true
+        };
+      }
+    } else {
+      baseArgs = cmdDef.base;
+    }
+    const allArgs = [...baseArgs, ...args ?? [], ...flags ?? []];
     const result = await runCommand(
       { command: resolved.command, env: resolved.env },
       allArgs,
-      process.cwd(),
+      cwd,
       { quiet: true }
-    );
+    ).promise;
     return {
       content: [{
         type: "text",
@@ -14084,5 +14108,366 @@ server.tool(
     };
   }
 );
+function pkgRunHelper(base, extraArgs = []) {
+  const cwd = process.cwd();
+  const translated = resolvePkgArgs(base, cwd);
+  const resolved = resolveToolCommand("pkg", cwd);
+  return runCommand(
+    { command: resolved.command, env: resolved.env },
+    [...translated.args, ...extraArgs],
+    cwd,
+    { quiet: true }
+  ).promise;
+}
+server.tool(
+  "polter_pkg_build",
+  "Run the build script from package.json using the detected package manager.",
+  {},
+  async () => {
+    const result = await pkgRunHelper(["run", "build"]);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+    };
+  }
+);
+server.tool(
+  "polter_pkg_publish",
+  "Publish the package to the npm registry.",
+  {
+    tag: external_exports.string().optional().describe("Dist-tag (e.g. 'next', 'beta')"),
+    dryRun: external_exports.boolean().optional().describe("Simulate publish without uploading")
+  },
+  async ({ tag, dryRun }) => {
+    const extra = [];
+    if (tag) extra.push("--tag", tag);
+    if (dryRun) extra.push("--dry-run");
+    try {
+      const result = await pkgRunHelper(["publish"], extra);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "polter_pkg_install",
+  "Install dependencies. Optionally install specific packages.",
+  {
+    packages: external_exports.array(external_exports.string()).optional().describe("Specific packages to install"),
+    dev: external_exports.boolean().optional().describe("Install as dev dependency")
+  },
+  async ({ packages, dev }) => {
+    const base = packages && packages.length > 0 ? ["add"] : ["install"];
+    const extra = [...packages ?? []];
+    if (dev) extra.push("--save-dev");
+    const result = await pkgRunHelper(base, extra);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+    };
+  }
+);
+server.tool(
+  "polter_pkg_run_script",
+  "Run a script defined in package.json.",
+  {
+    script: external_exports.string().describe("Script name to run"),
+    args: external_exports.array(external_exports.string()).optional().describe("Extra arguments")
+  },
+  async ({ script, args }) => {
+    const result = await pkgRunHelper(["run", script], args ?? []);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+    };
+  }
+);
+server.tool(
+  "polter_pkg_version_bump",
+  "Bump the package version (semver).",
+  {
+    type: external_exports.enum(["patch", "minor", "major"]).describe("Version bump type")
+  },
+  async ({ type }) => {
+    const result = await pkgRunHelper(["version", type]);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+    };
+  }
+);
+server.tool(
+  "polter_pkg_audit",
+  "Run a security audit on dependencies.",
+  {
+    fix: external_exports.boolean().optional().describe("Attempt to fix vulnerabilities")
+  },
+  async ({ fix }) => {
+    try {
+      const extra = fix ? ["--fix"] : [];
+      const result = await pkgRunHelper(["audit"], extra);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "polter_pkg_info",
+  "Get information about a package from the registry.",
+  {
+    package: external_exports.string().describe("Package name to look up")
+  },
+  async ({ package: pkg }) => {
+    try {
+      const result = await pkgRunHelper(["info", pkg]);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: result.exitCode === 0, stdout: result.stdout, stderr: result.stderr }, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "polter_ps",
+  "List all tracked background processes with their status, PID, uptime, and exit info.",
+  {},
+  async () => {
+    const processes = listProcesses();
+    return {
+      content: [{ type: "text", text: JSON.stringify(processes, null, 2) }]
+    };
+  }
+);
+server.tool(
+  "polter_start",
+  "Start a command as a tracked background process. Useful for long-running tasks like dev servers. Output is captured and can be read with polter_logs.",
+  {
+    command: external_exports.string().describe("Command to run (e.g. 'npm')"),
+    args: external_exports.array(external_exports.string()).optional().describe("Command arguments (e.g. ['run', 'dev'])"),
+    id: external_exports.string().optional().describe("Human-readable process ID. Auto-generated if omitted."),
+    cwd: external_exports.string().optional().describe("Working directory. Defaults to current directory.")
+  },
+  async ({ command, args, id, cwd }) => {
+    const processArgs = args ?? [];
+    const processId = id ?? generateProcessId(command, processArgs);
+    const processCwd = cwd ?? process.cwd();
+    try {
+      const info = startProcess(processId, command, processArgs, processCwd);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: true, process: info }, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "polter_logs",
+  "Read captured stdout/stderr from a tracked background process.",
+  {
+    id: external_exports.string().describe("Process ID"),
+    tail: external_exports.number().optional().describe("Number of lines to return from the end (default: all)"),
+    stream: external_exports.enum(["stdout", "stderr", "both"]).optional().describe("Which output stream to read (default: both)")
+  },
+  async ({ id, tail, stream }) => {
+    try {
+      const output = getProcessOutput(id, tail, stream);
+      return {
+        content: [{ type: "text", text: JSON.stringify(output, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.tool(
+  "polter_stop",
+  "Stop a tracked background process. Sends SIGTERM, escalates to SIGKILL after 5 seconds.",
+  {
+    id: external_exports.string().describe("Process ID to stop")
+  },
+  async ({ id }) => {
+    try {
+      const info = await stopProcess(id);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ success: true, process: info }, null, 2) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  }
+);
+server.resource(
+  "package-json",
+  "polter://package-json",
+  { description: "Parsed package.json (name, version, dependencies, scripts)" },
+  async () => {
+    const cwd = process.cwd();
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) {
+      return { contents: [{ uri: "polter://package-json", text: JSON.stringify({ error: "No package.json found" }) }] };
+    }
+    const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const summary = {
+      name: raw.name,
+      version: raw.version,
+      description: raw.description,
+      dependencies: raw.dependencies,
+      devDependencies: raw.devDependencies,
+      scripts: raw.scripts
+    };
+    return { contents: [{ uri: "polter://package-json", text: JSON.stringify(summary, null, 2) }] };
+  }
+);
+server.resource(
+  "dependency-tree",
+  "polter://dependency-tree",
+  { description: "Installed dependency tree (npm ls --json or equivalent)" },
+  async () => {
+    const cwd = process.cwd();
+    try {
+      const result = await pkgRunHelper(["ls", "--json"]);
+      return { contents: [{ uri: "polter://dependency-tree", text: result.stdout }] };
+    } catch {
+      return { contents: [{ uri: "polter://dependency-tree", text: JSON.stringify({ error: "Could not list dependencies" }) }] };
+    }
+  }
+);
+server.resource(
+  "scripts",
+  "polter://scripts",
+  { description: "Scripts defined in package.json" },
+  async () => {
+    const cwd = process.cwd();
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) {
+      return { contents: [{ uri: "polter://scripts", text: JSON.stringify({ error: "No package.json found" }) }] };
+    }
+    const raw = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return { contents: [{ uri: "polter://scripts", text: JSON.stringify(raw.scripts ?? {}, null, 2) }] };
+  }
+);
+server.resource(
+  "pkg-manager",
+  "polter://pkg-manager",
+  { description: "Detected package manager info (id, version, lockFile)" },
+  async () => {
+    const cwd = process.cwd();
+    const mgr = detectPkgManager(cwd);
+    const resolved = resolveToolCommand("pkg", cwd);
+    let version2;
+    if (resolved.source !== "not-found") {
+      try {
+        const result = await runCommand(
+          { command: resolved.command, env: resolved.env },
+          ["--version"],
+          cwd,
+          { quiet: true }
+        ).promise;
+        version2 = result.stdout.trim().split("\n")[0];
+      } catch {
+      }
+    }
+    return {
+      contents: [{
+        uri: "polter://pkg-manager",
+        text: JSON.stringify({ id: mgr.id, command: mgr.command, lockFile: mgr.lockFile, version: version2 }, null, 2)
+      }]
+    };
+  }
+);
+server.prompt(
+  "polter_publish_workflow",
+  "Step-by-step guide for publishing a package: version bump, build, test, publish, git tag.",
+  {},
+  async () => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Guide me through a complete publish workflow for this project:
+
+1. **Version bump** - Choose patch/minor/major based on changes since last release
+2. **Build** - Run the build script to ensure dist is up to date
+3. **Test** - Run the test suite to verify everything passes
+4. **Publish** - Publish to npm registry (consider --dry-run first)
+5. **Git tag** - Create and push a git tag for the release
+
+Use polter tools to execute each step. Check package.json for current version and scripts first.`
+      }
+    }]
+  })
+);
+server.prompt(
+  "polter_version_strategy",
+  "Suggest a semver versioning strategy based on current version and change type.",
+  {
+    currentVersion: external_exports.string().describe("Current package version"),
+    changeType: external_exports.string().describe("Type of change: feature, fix, breaking, docs, etc.")
+  },
+  async ({ currentVersion, changeType }) => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Current version: ${currentVersion}
+Change type: ${changeType}
+
+Based on semver rules:
+- PATCH (x.y.Z): backwards-compatible bug fixes
+- MINOR (x.Y.z): backwards-compatible new features
+- MAJOR (X.y.z): breaking changes
+
+Recommend the appropriate version bump and explain the reasoning. If pre-1.0, note that minor can include breaking changes by convention.`
+      }
+    }]
+  })
+);
+server.prompt(
+  "polter_audit_resolution",
+  "Guide for analyzing and resolving npm audit findings.",
+  {},
+  async () => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Run a security audit on this project and help me resolve any findings:
+
+1. **Run audit** - Use polter_pkg_audit to check for vulnerabilities
+2. **Analyze results** - Categorize by severity (critical, high, moderate, low)
+3. **Resolution strategy** for each finding:
+   - Direct dependency: update to patched version
+   - Transitive dependency: check if parent has update
+   - No fix available: evaluate risk and consider alternatives
+4. **Apply fixes** - Use polter_pkg_install to update packages
+5. **Verify** - Re-run audit to confirm fixes
+
+Start by running the audit.`
+      }
+    }]
+  })
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polterware/polter",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "An interactive CLI for managing Supabase CLI workflows.",
   "type": "module",
   "bin": {