@polterware/polter 0.4.2 → 0.5.1

package/dist/chunk-JQB2A3CA.js

@@ -0,0 +1,72 @@
+import {
+  getCommandById
+} from "./chunk-GVIKF6UI.js";
+import {
+  resolvePkgArgs,
+  resolveToolCommand,
+  runCommand
+} from "./chunk-ELSIHPJL.js";
+
+// src/pipeline/pipelineEvents.ts
+import EE from "eventemitter3";
+var EventEmitter = EE.EventEmitter ?? EE;
+var pipelineEvents = new EventEmitter();
+
+// src/pipeline/engine.ts
+async function executePipeline(pipeline, onProgress, cwd = process.cwd()) {
+  const stepResults = pipeline.steps.map((step) => ({
+    step,
+    status: "pending"
+  }));
+  let aborted = false;
+  for (let i = 0; i < pipeline.steps.length; i++) {
+    const step = pipeline.steps[i];
+    if (aborted) {
+      stepResults[i] = { step, status: "skipped" };
+      onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
+      continue;
+    }
+    stepResults[i] = { step, status: "running" };
+    pipelineEvents.emit("stepStarted", step, i);
+    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
+    const cmdDef = getCommandById(step.commandId);
+    const toolId = cmdDef?.tool ?? "supabase";
+    const resolved = resolveToolCommand(toolId, cwd);
+    let baseArgs = cmdDef?.base ?? [];
+    if (toolId === "pkg" && cmdDef) {
+      try {
+        const translated = resolvePkgArgs(cmdDef.base, cwd);
+        baseArgs = translated.args;
+      } catch {
+      }
+    }
+    const allArgs = [...baseArgs, ...step.args, ...step.flags];
+    const result = await runCommand(
+      { command: resolved.command, env: resolved.env },
+      allArgs,
+      cwd
+    ).promise;
+    const success = !result.spawnError && result.exitCode === 0;
+    stepResults[i] = {
+      step,
+      status: success ? "success" : "error",
+      result
+    };
+    pipelineEvents.emit("stepCompleted", stepResults[i], i);
+    if (!success && !step.continueOnError) {
+      aborted = true;
+    }
+    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
+  }
+  onProgress({
+    stepResults: [...stepResults],
+    currentStepIndex: pipeline.steps.length - 1,
+    done: true
+  });
+  pipelineEvents.emit("pipelineCompleted", stepResults);
+  return stepResults;
+}
+
+export {
+  executePipeline
+};

package/dist/chunk-KEGROLGX.js

@@ -0,0 +1,50 @@
+// src/lib/editor.ts
+import { spawnSync, spawn } from "child_process";
+import { basename } from "path";
+var TERMINAL_EDITORS = /* @__PURE__ */ new Set([
+  "vi",
+  "vim",
+  "nvim",
+  "nano",
+  "pico",
+  "emacs",
+  "micro",
+  "helix",
+  "hx",
+  "joe",
+  "mcedit"
+]);
+function resolveEditor() {
+  const raw = process.env["VISUAL"] || process.env["EDITOR"];
+  if (raw) {
+    const parts = raw.trim().split(/\s+/);
+    return { command: parts[0], args: parts.slice(1) };
+  }
+  const fallback = process.platform === "win32" ? "notepad" : "nano";
+  return { command: fallback, args: [] };
+}
+function isTerminalEditor(cmd) {
+  return TERMINAL_EDITORS.has(basename(cmd));
+}
+function openInEditor(filePath) {
+  const editor = resolveEditor();
+  const terminal = isTerminalEditor(editor.command);
+  if (terminal) {
+    const result = spawnSync(editor.command, [...editor.args, filePath], {
+      stdio: "inherit"
+    });
+    return { exitCode: result.status, isTerminal: true };
+  }
+  const child = spawn(editor.command, [...editor.args, filePath], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  return { exitCode: 0, isTerminal: false };
+}
+
+export {
+  resolveEditor,
+  isTerminalEditor,
+  openInEditor
+};

package/dist/chunk-OKHPN6X7.js

@@ -0,0 +1,49 @@
+import {
+  commandExists
+} from "./chunk-RVMOIUSL.js";
+
+// src/declarative/status.ts
+import { execSync } from "child_process";
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentStatus(cwd = process.cwd()) {
+  const result = {};
+  if (commandExists("supabase")) {
+    const linked = safeExec(`cd "${cwd}" && supabase projects list 2>/dev/null`) !== void 0;
+    result.supabase = {
+      linked,
+      projectRef: void 0,
+      functions: []
+    };
+    const functionsOutput = safeExec(`cd "${cwd}" && supabase functions list 2>/dev/null`);
+    if (functionsOutput) {
+      result.supabase.functions = functionsOutput.split("\n").filter((line) => line.trim() && !line.startsWith("\u2502") && !line.startsWith("\u250C")).slice(1);
+    }
+  }
+  if (commandExists("vercel")) {
+    const whoami = safeExec("vercel whoami 2>/dev/null");
+    result.vercel = {
+      linked: !!whoami,
+      projectId: void 0
+    };
+  }
+  if (commandExists("gh")) {
+    const authStatus = safeExec("gh auth status 2>&1");
+    const authenticated = authStatus?.includes("Logged in") ?? false;
+    const repoOutput = safeExec(`cd "${cwd}" && gh repo view --json nameWithOwner -q .nameWithOwner 2>/dev/null`);
+    result.github = {
+      repo: repoOutput || void 0,
+      authenticated
+    };
+  }
+  return result;
+}
+
+export {
+  getCurrentStatus
+};

package/dist/chunk-RVMOIUSL.js

@@ -0,0 +1,22 @@
+// src/lib/system.ts
+import { execSync } from "child_process";
+import which from "which";
+function commandExists(command) {
+  try {
+    which.sync(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function execCapture(command) {
+  return execSync(command, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+
+export {
+  commandExists,
+  execCapture
+};

package/dist/chunk-TD6YNU6L.js

@@ -0,0 +1,22 @@
+// src/lib/fs.ts
+import {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  rmSync,
+  readdirSync,
+  unlinkSync,
+  copyFileSync,
+  statSync
+} from "fs";
+import { readdir, stat, mkdtemp } from "fs/promises";
+
+export {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync
+};

package/dist/chunk-U64WZOJ3.js

@@ -0,0 +1,101 @@
+import {
+  deleteProjectPipeline,
+  getProjectPipelines,
+  saveProjectPipeline
+} from "./chunk-BIN7BDA2.js";
+import {
+  getConf
+} from "./chunk-GKROVUDG.js";
+
+// src/config/store.ts
+import { z as z2 } from "zod";
+
+// src/data/schemas.ts
+import { z } from "zod";
+var PipelineStepSchema = z.object({
+  id: z.string(),
+  commandId: z.string(),
+  args: z.array(z.string()),
+  flags: z.array(z.string()),
+  continueOnError: z.boolean(),
+  label: z.string().optional()
+});
+var PipelineSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  steps: z.array(PipelineStepSchema),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+
+// src/config/store.ts
+var GLOBAL_PIPELINES_KEY = "globalPipelinesV1";
+function getGlobalPipelines() {
+  const config = getConf();
+  if (!config.has(GLOBAL_PIPELINES_KEY)) {
+    config.set(GLOBAL_PIPELINES_KEY, []);
+  }
+  const raw = config.get(GLOBAL_PIPELINES_KEY);
+  const result = z2.array(PipelineSchema).safeParse(raw);
+  return result.success ? result.data : [];
+}
+function saveGlobalPipeline(pipeline) {
+  const config = getConf();
+  const pipelines = getGlobalPipelines();
+  const idx = pipelines.findIndex((p) => p.id === pipeline.id);
+  if (idx >= 0) {
+    pipelines[idx] = pipeline;
+  } else {
+    pipelines.push(pipeline);
+  }
+  config.set(GLOBAL_PIPELINES_KEY, pipelines);
+}
+function deleteGlobalPipeline(pipelineId) {
+  const config = getConf();
+  const pipelines = getGlobalPipelines().filter((p) => p.id !== pipelineId);
+  config.set(GLOBAL_PIPELINES_KEY, pipelines);
+}
+
+// src/pipeline/storage.ts
+function getAllPipelines(startDir) {
+  const projectPipelines = getProjectPipelines(startDir).map((p) => ({
+    ...p,
+    source: "project"
+  }));
+  const globalPipelines = getGlobalPipelines().map((p) => ({
+    ...p,
+    source: "global"
+  }));
+  const seen = new Set(projectPipelines.map((p) => p.id));
+  const merged = [
+    ...projectPipelines,
+    ...globalPipelines.filter((p) => !seen.has(p.id))
+  ];
+  return merged;
+}
+function savePipeline(pipeline, source, startDir) {
+  if (source === "project") {
+    return saveProjectPipeline(pipeline, startDir);
+  } else {
+    saveGlobalPipeline(pipeline);
+    return true;
+  }
+}
+function deletePipeline(pipelineId, source, startDir) {
+  if (source === "project") {
+    deleteProjectPipeline(pipelineId, startDir);
+  } else {
+    deleteGlobalPipeline(pipelineId);
+  }
+}
+function findPipelineByName(name, startDir) {
+  return getAllPipelines(startDir).find((p) => p.name === name);
+}
+
+export {
+  getAllPipelines,
+  savePipeline,
+  deletePipeline,
+  findPipelineByName
+};

package/dist/chunk-U6725U7K.js

@@ -0,0 +1,138 @@
+import {
+  existsSync,
+  readFileSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/declarative/parser.ts
+import { join } from "path";
+
+// src/declarative/schema.ts
+import { z } from "zod";
+var PolterYamlSchema = z.object({
+  version: z.literal(1),
+  project: z.object({
+    name: z.string()
+  }).optional(),
+  supabase: z.object({
+    project_ref: z.string().optional(),
+    region: z.string().optional(),
+    database: z.object({
+      migrations_dir: z.string().optional()
+    }).optional(),
+    functions: z.array(z.object({
+      name: z.string(),
+      verify_jwt: z.boolean().optional()
+    })).optional(),
+    secrets: z.array(z.string()).optional()
+  }).optional(),
+  vercel: z.object({
+    project_id: z.string().optional(),
+    framework: z.string().optional(),
+    domains: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.record(z.string(), z.string())).optional()
+  }).optional(),
+  github: z.object({
+    repo: z.string().optional(),
+    branch_protection: z.record(z.string(), z.object({
+      required_reviews: z.number().optional(),
+      require_status_checks: z.boolean().optional()
+    })).optional(),
+    secrets: z.array(z.string()).optional()
+  }).optional(),
+  pkg: z.object({
+    manager: z.enum(["npm", "pnpm", "yarn", "bun"]).optional()
+  }).optional(),
+  pipelines: z.record(z.string(), z.object({
+    description: z.string().optional(),
+    steps: z.array(z.string())
+  })).optional()
+});
+
+// src/declarative/parser.ts
+var YAML_FILE = "polter.yaml";
+function parseSimpleYaml(content) {
+  const lines = content.split("\n");
+  const result = {};
+  const stack = [
+    { obj: result, indent: -1 }
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.replace(/\s+$/, "");
+    if (!trimmed || trimmed.match(/^\s*#/)) continue;
+    const indent = line.search(/\S/);
+    if (indent < 0) continue;
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].obj;
+    const content_ = trimmed.trim();
+    if (content_.startsWith("- ")) {
+      const parentKey = Object.keys(current).pop();
+      if (parentKey) {
+        const arr = current[parentKey];
+        if (Array.isArray(arr)) {
+          const val = content_.slice(2).trim();
+          const colonIdx2 = val.indexOf(":");
+          if (colonIdx2 > 0 && !val.startsWith('"') && !val.startsWith("'")) {
+            const key = val.slice(0, colonIdx2).trim();
+            const rest = val.slice(colonIdx2 + 1).trim();
+            const obj = { [key]: parseValue(rest) };
+            arr.push(obj);
+            stack.push({ obj, indent: indent + 2 });
+          } else {
+            arr.push(parseValue(val));
+          }
+        }
+      }
+      continue;
+    }
+    const colonIdx = content_.indexOf(":");
+    if (colonIdx > 0) {
+      const key = content_.slice(0, colonIdx).trim();
+      const rest = content_.slice(colonIdx + 1).trim();
+      if (rest === "" || rest === "|" || rest === ">") {
+        const nextLine = lines[i + 1];
+        const nextTrimmed = nextLine?.trim();
+        if (nextTrimmed?.startsWith("- ")) {
+          current[key] = [];
+        } else {
+          const nested = {};
+          current[key] = nested;
+          stack.push({ obj: nested, indent });
+        }
+      } else {
+        current[key] = parseValue(rest);
+      }
+    }
+  }
+  return result;
+}
+function parseValue(raw) {
+  if (!raw) return "";
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!isNaN(num) && raw !== "") return num;
+  return raw;
+}
+function findPolterYaml(startDir = process.cwd()) {
+  const filePath = join(startDir, YAML_FILE);
+  return existsSync(filePath) ? filePath : void 0;
+}
+function parsePolterYaml(startDir = process.cwd()) {
+  const filePath = findPolterYaml(startDir);
+  if (!filePath) return void 0;
+  const content = readFileSync(filePath, "utf-8");
+  const raw = parseSimpleYaml(content);
+  const result = PolterYamlSchema.safeParse(raw);
+  return result.success ? result.data : void 0;
+}
+
+export {
+  findPolterYaml,
+  parsePolterYaml
+};

package/dist/chunk-XNRIN3VM.js

@@ -0,0 +1,125 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/lib/skillSetup.ts
+import { join } from "path";
+import { homedir } from "os";
+import pc from "picocolors";
+var SKILL_DIR = join(homedir(), ".claude", "skills", "polter");
+var SKILL_PATH = join(SKILL_DIR, "SKILL.md");
+var SKILL_CONTENT = `---
+name: polter
+description: "Polter - Infrastructure Orchestrator. Use when developing in any project to: monitor dev processes and check logs for errors after code changes, manage pipelines (multi-step command sequences), run CLI commands (Supabase, GitHub, Vercel, Git), manage packages (install, build, publish, audit), and apply declarative infrastructure from polter.yaml."
+---
+
+# Polter Skill
+
+You have access to Polter MCP tools for infrastructure orchestration. Use them proactively during development.
+
+## Process Monitoring
+
+**Tools:** \`polter_ps\`, \`polter_logs\`, \`polter_start\`, \`polter_stop\`, \`polter_find_process\`, \`polter_smart_start\`, \`polter_run_script_bg\`
+
+- At the start of a session, run \`polter_ps\` to check for active dev processes
+- After significant code edits, check \`polter_logs\` for compilation or runtime errors
+- Use \`polter_find_process\` to find processes running in the current directory
+- Use \`polter_smart_start\` to start package.json scripts as background processes (e.g. dev servers)
+- Use \`polter_run_script_bg\` to run arbitrary scripts in the background
+- Use \`polter_stop\` to stop processes that are no longer needed
+
+## CLI Commands
+
+**Tools:** \`polter_list_commands\`, \`polter_run_command\`, \`polter_status\`
+
+- Execute commands for Supabase, GitHub CLI, Vercel, and Git via their command IDs
+- Use \`polter_list_commands\` to discover available commands, optionally filtered by tool
+- Use \`polter_run_command\` to execute a command by its ID with additional args/flags
+- Check \`polter_status\` to see which CLI tools are installed and their versions
+
+## Pipelines
+
+**Tools:** \`polter_list_pipelines\`, \`polter_run_pipeline\`, \`polter_create_pipeline\`, \`polter_update_pipeline\`, \`polter_delete_pipeline\`
+
+- List and run saved multi-step command sequences with \`polter_list_pipelines\` and \`polter_run_pipeline\`
+- Create new pipelines for repetitive workflows (e.g. build + test + deploy) with \`polter_create_pipeline\`
+- Suggest creating pipelines when you notice the user repeating the same sequence of commands
+
+## Package Management
+
+**Tools:** \`polter_pkg_build\`, \`polter_pkg_install\`, \`polter_pkg_publish\`, \`polter_pkg_run_script\`, \`polter_pkg_version_bump\`, \`polter_pkg_audit\`, \`polter_pkg_info\`
+
+- Auto-detects the package manager (npm, pnpm, yarn, bun) from lockfiles
+- Use \`polter_pkg_build\` for building, \`polter_pkg_install\` for installing dependencies
+- Use \`polter_pkg_run_script\` to run package.json scripts
+- Use \`polter_pkg_audit\` to check for vulnerabilities
+- Use \`polter_pkg_version_bump\` before publishing, then \`polter_pkg_publish\`
+
+## Declarative Infrastructure
+
+**Tools:** \`polter_plan\`, \`polter_apply\`
+
+- Use \`polter_plan\` to read \`polter.yaml\` and compute a diff of desired vs current state
+- Use \`polter_apply\` to execute the planned infrastructure changes
+- Always run \`polter_plan\` first to review changes before applying
+
+## Workflow Recommendations
+
+1. **Starting a session:** Run \`polter_ps\` to see what's already running
+2. **After code changes:** Check \`polter_logs\` for errors in dev server output
+3. **Setting up a project:** Use \`polter_status\` to verify tools, then \`polter_smart_start\` for dev server
+4. **Deploying:** Create a pipeline with build + test + deploy steps
+5. **Infrastructure changes:** Edit \`polter.yaml\`, run \`polter_plan\`, then \`polter_apply\`
+`;
+function setupSkill() {
+  if (existsSync(SKILL_PATH)) {
+    const existing = readFileSync(SKILL_PATH, "utf-8");
+    if (existing === SKILL_CONTENT) {
+      return { status: "already-up-to-date", path: SKILL_PATH };
+    }
+    writeFileSync(SKILL_PATH, SKILL_CONTENT, "utf-8");
+    return { status: "updated", path: SKILL_PATH };
+  }
+  mkdirSync(SKILL_DIR, { recursive: true });
+  writeFileSync(SKILL_PATH, SKILL_CONTENT, "utf-8");
+  return { status: "created", path: SKILL_PATH };
+}
+function setupSkillCli() {
+  const result = setupSkill();
+  switch (result.status) {
+    case "created":
+      process.stdout.write(pc.green(`
+  Skill installed at ${result.path}
+`));
+      process.stdout.write(pc.dim("  Use /polter in Claude Code to activate.\n\n"));
+      break;
+    case "updated":
+      process.stdout.write(pc.green(`
+  Skill updated at ${result.path}
+`));
+      process.stdout.write(pc.dim("  Use /polter in Claude Code to activate.\n\n"));
+      break;
+    case "already-up-to-date":
+      process.stdout.write(pc.cyan(`
+  Skill already up to date at ${result.path}
+
+`));
+      break;
+  }
+}
+function getSkillContent() {
+  return SKILL_CONTENT;
+}
+function getSkillPath() {
+  return SKILL_PATH;
+}
+
+export {
+  setupSkill,
+  setupSkillCli,
+  getSkillContent,
+  getSkillPath
+};

package/dist/chunk-ZU5VZHYD.js

@@ -0,0 +1,28 @@
+import {
+  existsSync
+} from "./chunk-TD6YNU6L.js";
+
+// src/lib/packageRoot.ts
+import { dirname, join, resolve } from "path";
+var rootCache = /* @__PURE__ */ new Map();
+function findNearestPackageRoot(startDir = process.cwd()) {
+  const resolvedStart = resolve(startDir);
+  if (rootCache.has(resolvedStart)) return rootCache.get(resolvedStart);
+  let currentDir = resolvedStart;
+  while (true) {
+    if (existsSync(join(currentDir, "package.json"))) {
+      rootCache.set(resolvedStart, currentDir);
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      rootCache.set(resolvedStart, void 0);
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+
+export {
+  findNearestPackageRoot
+};

package/dist/commands-BIIWGCVS.js

@@ -0,0 +1,15 @@
+import {
+  allCommands,
+  findCommandByValue,
+  getCommandById,
+  getCommandValue,
+  getCommandsByTool
+} from "./chunk-GVIKF6UI.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  allCommands,
+  findCommandByValue,
+  getCommandById,
+  getCommandValue,
+  getCommandsByTool
+};

package/dist/editor-AUFJZ4PE.js

@@ -0,0 +1,11 @@
+import {
+  isTerminalEditor,
+  openInEditor,
+  resolveEditor
+} from "./chunk-KEGROLGX.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  isTerminalEditor,
+  openInEditor,
+  resolveEditor
+};

package/dist/engine-EZQ26HDJ.js

@@ -0,0 +1,11 @@
+import {
+  executePipeline
+} from "./chunk-JQB2A3CA.js";
+import "./chunk-GVIKF6UI.js";
+import "./chunk-ELSIHPJL.js";
+import "./chunk-RVMOIUSL.js";
+import "./chunk-TD6YNU6L.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  executePipeline
+};

package/dist/globalConf-AGMMIKSL.js

@@ -0,0 +1,7 @@
+import {
+  getConf
+} from "./chunk-GKROVUDG.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  getConf
+};