@polterware/polter 0.0.0 → 0.1.1

package/dist/chunk-TWWRDI3Q.js

@@ -0,0 +1,1488 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/data/commands/supabase.ts
+var supabaseCommands = [
+  // Quick Start
+  {
+    id: "supabase:bootstrap",
+    tool: "supabase",
+    base: ["bootstrap"],
+    label: "bootstrap",
+    hint: "Bootstrap from a starter template"
+  },
+  {
+    id: "supabase:init",
+    tool: "supabase",
+    base: ["init"],
+    label: "init",
+    hint: "Initialize a local project"
+  },
+  {
+    id: "supabase:login",
+    tool: "supabase",
+    base: ["login"],
+    label: "login",
+    hint: "Authenticate with access token"
+  },
+  {
+    id: "supabase:logout",
+    tool: "supabase",
+    base: ["logout"],
+    label: "logout",
+    hint: "Remove local auth token"
+  },
+  // Local Dev
+  {
+    id: "supabase:start",
+    tool: "supabase",
+    base: ["start"],
+    label: "start",
+    hint: "Start local Supabase containers"
+  },
+  {
+    id: "supabase:stop",
+    tool: "supabase",
+    base: ["stop"],
+    label: "stop",
+    hint: "Stop local Supabase containers"
+  },
+  {
+    id: "supabase:status",
+    tool: "supabase",
+    base: ["status"],
+    label: "status",
+    hint: "Show container status"
+  },
+  {
+    id: "supabase:db",
+    tool: "supabase",
+    base: ["db"],
+    label: "db",
+    hint: "Manage Postgres databases",
+    suggestedArgs: [
+      { value: "pull", label: "pull", hint: "Pull schema from remote", args: ["pull"] },
+      { value: "push", label: "push", hint: "Push local migrations", args: ["push"] },
+      { value: "reset", label: "reset", hint: "Reset local database", args: ["reset"] },
+      { value: "dump", label: "dump", hint: "Dump schema/data", args: ["dump"] },
+      { value: "diff", label: "diff", hint: "Show migration diff", args: ["diff"] },
+      { value: "lint", label: "lint", hint: "Lint SQL migrations", args: ["lint"] }
+    ]
+  },
+  {
+    id: "supabase:migration",
+    tool: "supabase",
+    base: ["migration"],
+    label: "migration",
+    hint: "Manage migration scripts",
+    suggestedArgs: [
+      { value: "new", label: "new <name>", hint: "Create migration file", args: ["new"] },
+      { value: "up", label: "up", hint: "Apply pending migrations", args: ["up"] },
+      { value: "down", label: "down", hint: "Rollback last migration", args: ["down"] },
+      { value: "list", label: "list", hint: "List local migrations", args: ["list"] },
+      { value: "repair", label: "repair", hint: "Repair migration history", args: ["repair"] },
+      { value: "fetch", label: "fetch", hint: "Fetch migration history", args: ["fetch"] }
+    ]
+  },
+  {
+    id: "supabase:seed",
+    tool: "supabase",
+    base: ["seed"],
+    label: "seed",
+    hint: "Seed from config.toml",
+    suggestedArgs: [
+      { value: "run", label: "run", hint: "Run configured seed file", args: ["run"] }
+    ]
+  },
+  {
+    id: "supabase:test",
+    tool: "supabase",
+    base: ["test"],
+    label: "test",
+    hint: "Run tests on local stack"
+  },
+  // Inspect & Generate
+  {
+    id: "supabase:inspect",
+    tool: "supabase",
+    base: ["inspect"],
+    label: "inspect",
+    hint: "Inspect project resources"
+  },
+  {
+    id: "supabase:gen",
+    tool: "supabase",
+    base: ["gen"],
+    label: "gen",
+    hint: "Run code generation tools"
+  },
+  {
+    id: "supabase:services",
+    tool: "supabase",
+    base: ["services"],
+    label: "services",
+    hint: "Show service versions"
+  },
+  {
+    id: "supabase:link",
+    tool: "supabase",
+    base: ["link"],
+    label: "link",
+    hint: "Link to remote project"
+  },
+  {
+    id: "supabase:unlink",
+    tool: "supabase",
+    base: ["unlink"],
+    label: "unlink",
+    hint: "Unlink remote project"
+  },
+  // Cloud Management
+  {
+    id: "supabase:projects",
+    tool: "supabase",
+    base: ["projects"],
+    label: "projects",
+    hint: "Manage Supabase projects",
+    suggestedArgs: [
+      { value: "list", label: "list", hint: "List projects", args: ["list"] },
+      { value: "create", label: "create", hint: "Create project", args: ["create"] },
+      { value: "delete", label: "delete", hint: "Delete project", args: ["delete"] }
+    ]
+  },
+  {
+    id: "supabase:functions",
+    tool: "supabase",
+    base: ["functions"],
+    label: "functions",
+    hint: "Manage Edge Functions",
+    suggestedArgs: [
+      { value: "list", label: "list", hint: "List functions", args: ["list"] },
+      { value: "new", label: "new <name>", hint: "Create a function", args: ["new"] },
+      { value: "serve", label: "serve", hint: "Serve functions locally", args: ["serve"] },
+      { value: "deploy", label: "deploy <name>", hint: "Deploy function", args: ["deploy"] },
+      { value: "delete", label: "delete <name>", hint: "Delete function", args: ["delete"] }
+    ]
+  },
+  {
+    id: "supabase:secrets",
+    tool: "supabase",
+    base: ["secrets"],
+    label: "secrets",
+    hint: "Manage project secrets"
+  },
+  {
+    id: "supabase:config",
+    tool: "supabase",
+    base: ["config"],
+    label: "config",
+    hint: "Manage project configuration"
+  },
+  {
+    id: "supabase:storage",
+    tool: "supabase",
+    base: ["storage"],
+    label: "storage",
+    hint: "Manage Storage objects",
+    suggestedArgs: [
+      { value: "ls", label: "ls", hint: "List storage objects", args: ["ls"] },
+      { value: "cp", label: "cp", hint: "Copy storage object", args: ["cp"] },
+      { value: "mv", label: "mv", hint: "Move storage object", args: ["mv"] },
+      { value: "rm", label: "rm", hint: "Remove storage object", args: ["rm"] }
+    ]
+  },
+  // Networking & Security
+  {
+    id: "supabase:domains",
+    tool: "supabase",
+    base: ["domains"],
+    label: "domains",
+    hint: "Manage custom domains"
+  },
+  {
+    id: "supabase:ssl-enforcement",
+    tool: "supabase",
+    base: ["ssl-enforcement"],
+    label: "ssl-enforcement",
+    hint: "Manage SSL config"
+  },
+  {
+    id: "supabase:network-bans",
+    tool: "supabase",
+    base: ["network-bans"],
+    label: "network-bans",
+    hint: "Manage network bans"
+  },
+  {
+    id: "supabase:network-restrictions",
+    tool: "supabase",
+    base: ["network-restrictions"],
+    label: "network-restrictions",
+    hint: "Manage network restrictions"
+  },
+  {
+    id: "supabase:vanity-subdomains",
+    tool: "supabase",
+    base: ["vanity-subdomains"],
+    label: "vanity-subdomains",
+    hint: "Manage vanity subdomains"
+  },
+  {
+    id: "supabase:encryption",
+    tool: "supabase",
+    base: ["encryption"],
+    label: "encryption",
+    hint: "Manage encryption keys"
+  },
+  // Organizations & Admin
+  {
+    id: "supabase:orgs",
+    tool: "supabase",
+    base: ["orgs"],
+    label: "orgs",
+    hint: "Manage organizations",
+    suggestedArgs: [
+      { value: "list", label: "list", hint: "List organizations", args: ["list"] },
+      { value: "create", label: "create", hint: "Create organization", args: ["create"] }
+    ]
+  },
+  {
+    id: "supabase:sso",
+    tool: "supabase",
+    base: ["sso"],
+    label: "sso",
+    hint: "Manage Single Sign-On"
+  },
+  {
+    id: "supabase:branches",
+    tool: "supabase",
+    base: ["branches"],
+    label: "branches",
+    hint: "Manage preview branches"
+  },
+  {
+    id: "supabase:backups",
+    tool: "supabase",
+    base: ["backups"],
+    label: "backups",
+    hint: "Manage physical backups",
+    suggestedArgs: [
+      { value: "list", label: "list", hint: "List backups", args: ["list"] },
+      { value: "download", label: "download", hint: "Download backup", args: ["download"] }
+    ]
+  },
+  {
+    id: "supabase:snippets",
+    tool: "supabase",
+    base: ["snippets"],
+    label: "snippets",
+    hint: "Manage SQL snippets",
+    suggestedArgs: [
+      { value: "list", label: "list", hint: "List SQL snippets", args: ["list"] },
+      { value: "create", label: "create", hint: "Create SQL snippet", args: ["create"] },
+      { value: "delete", label: "delete", hint: "Delete SQL snippet", args: ["delete"] }
+    ]
+  },
+  {
+    id: "supabase:postgres-config",
+    tool: "supabase",
+    base: ["postgres-config"],
+    label: "postgres-config",
+    hint: "Manage Postgres config"
+  },
+  // Utilities
+  {
+    id: "supabase:completion",
+    tool: "supabase",
+    base: ["completion"],
+    label: "completion",
+    hint: "Generate shell completion script"
+  },
+  {
+    id: "supabase:help",
+    tool: "supabase",
+    base: ["help"],
+    label: "help",
+    hint: "Help about any command"
+  }
+];
+
+// src/data/commands/gh.ts
+var ghCommands = [
+  // Repository
+  {
+    id: "gh:repo:clone",
+    tool: "gh",
+    base: ["repo", "clone"],
+    label: "repo clone",
+    hint: "Clone a repository"
+  },
+  {
+    id: "gh:repo:create",
+    tool: "gh",
+    base: ["repo", "create"],
+    label: "repo create",
+    hint: "Create a new repository"
+  },
+  {
+    id: "gh:repo:view",
+    tool: "gh",
+    base: ["repo", "view"],
+    label: "repo view",
+    hint: "View repository details"
+  },
+  {
+    id: "gh:repo:list",
+    tool: "gh",
+    base: ["repo", "list"],
+    label: "repo list",
+    hint: "List your repositories"
+  },
+  // Pull Requests
+  {
+    id: "gh:pr:create",
+    tool: "gh",
+    base: ["pr", "create"],
+    label: "pr create",
+    hint: "Create a pull request"
+  },
+  {
+    id: "gh:pr:list",
+    tool: "gh",
+    base: ["pr", "list"],
+    label: "pr list",
+    hint: "List pull requests"
+  },
+  {
+    id: "gh:pr:view",
+    tool: "gh",
+    base: ["pr", "view"],
+    label: "pr view",
+    hint: "View a pull request"
+  },
+  {
+    id: "gh:pr:merge",
+    tool: "gh",
+    base: ["pr", "merge"],
+    label: "pr merge",
+    hint: "Merge a pull request"
+  },
+  {
+    id: "gh:pr:checkout",
+    tool: "gh",
+    base: ["pr", "checkout"],
+    label: "pr checkout",
+    hint: "Check out a pull request"
+  },
+  // Issues
+  {
+    id: "gh:issue:create",
+    tool: "gh",
+    base: ["issue", "create"],
+    label: "issue create",
+    hint: "Create an issue"
+  },
+  {
+    id: "gh:issue:list",
+    tool: "gh",
+    base: ["issue", "list"],
+    label: "issue list",
+    hint: "List issues"
+  },
+  {
+    id: "gh:issue:view",
+    tool: "gh",
+    base: ["issue", "view"],
+    label: "issue view",
+    hint: "View an issue"
+  },
+  {
+    id: "gh:issue:close",
+    tool: "gh",
+    base: ["issue", "close"],
+    label: "issue close",
+    hint: "Close an issue"
+  },
+  // Workflows & Runs
+  {
+    id: "gh:workflow:list",
+    tool: "gh",
+    base: ["workflow", "list"],
+    label: "workflow list",
+    hint: "List workflows"
+  },
+  {
+    id: "gh:workflow:run",
+    tool: "gh",
+    base: ["workflow", "run"],
+    label: "workflow run",
+    hint: "Run a workflow"
+  },
+  {
+    id: "gh:workflow:view",
+    tool: "gh",
+    base: ["workflow", "view"],
+    label: "workflow view",
+    hint: "View a workflow"
+  },
+  {
+    id: "gh:run:list",
+    tool: "gh",
+    base: ["run", "list"],
+    label: "run list",
+    hint: "List workflow runs"
+  },
+  {
+    id: "gh:run:view",
+    tool: "gh",
+    base: ["run", "view"],
+    label: "run view",
+    hint: "View a workflow run"
+  },
+  {
+    id: "gh:run:watch",
+    tool: "gh",
+    base: ["run", "watch"],
+    label: "run watch",
+    hint: "Watch a workflow run"
+  },
+  // Releases
+  {
+    id: "gh:release:create",
+    tool: "gh",
+    base: ["release", "create"],
+    label: "release create",
+    hint: "Create a release"
+  },
+  {
+    id: "gh:release:list",
+    tool: "gh",
+    base: ["release", "list"],
+    label: "release list",
+    hint: "List releases"
+  },
+  {
+    id: "gh:release:view",
+    tool: "gh",
+    base: ["release", "view"],
+    label: "release view",
+    hint: "View a release"
+  },
+  // Auth
+  {
+    id: "gh:auth:login",
+    tool: "gh",
+    base: ["auth", "login"],
+    label: "auth login",
+    hint: "Log in to GitHub"
+  },
+  {
+    id: "gh:auth:status",
+    tool: "gh",
+    base: ["auth", "status"],
+    label: "auth status",
+    hint: "View auth status"
+  }
+];
+
+// src/data/commands/vercel.ts
+var vercelCommands = [
+  // Deploy
+  {
+    id: "vercel:deploy",
+    tool: "vercel",
+    base: ["deploy"],
+    label: "deploy",
+    hint: "Deploy to Vercel"
+  },
+  {
+    id: "vercel:deploy:prod",
+    tool: "vercel",
+    base: ["deploy", "--prod"],
+    label: "deploy --prod",
+    hint: "Deploy to production"
+  },
+  {
+    id: "vercel:promote",
+    tool: "vercel",
+    base: ["promote"],
+    label: "promote",
+    hint: "Promote a deployment"
+  },
+  {
+    id: "vercel:rollback",
+    tool: "vercel",
+    base: ["rollback"],
+    label: "rollback",
+    hint: "Rollback to previous deployment"
+  },
+  // Domains
+  {
+    id: "vercel:domains:list",
+    tool: "vercel",
+    base: ["domains", "ls"],
+    label: "domains ls",
+    hint: "List domains"
+  },
+  {
+    id: "vercel:domains:add",
+    tool: "vercel",
+    base: ["domains", "add"],
+    label: "domains add",
+    hint: "Add a domain"
+  },
+  {
+    id: "vercel:domains:rm",
+    tool: "vercel",
+    base: ["domains", "rm"],
+    label: "domains rm",
+    hint: "Remove a domain"
+  },
+  // Environment Variables
+  {
+    id: "vercel:env:ls",
+    tool: "vercel",
+    base: ["env", "ls"],
+    label: "env ls",
+    hint: "List environment variables"
+  },
+  {
+    id: "vercel:env:add",
+    tool: "vercel",
+    base: ["env", "add"],
+    label: "env add",
+    hint: "Add an environment variable"
+  },
+  {
+    id: "vercel:env:rm",
+    tool: "vercel",
+    base: ["env", "rm"],
+    label: "env rm",
+    hint: "Remove an environment variable"
+  },
+  {
+    id: "vercel:env:pull",
+    tool: "vercel",
+    base: ["env", "pull"],
+    label: "env pull",
+    hint: "Pull env vars to .env file"
+  },
+  // Project
+  {
+    id: "vercel:project:ls",
+    tool: "vercel",
+    base: ["project", "ls"],
+    label: "project ls",
+    hint: "List projects"
+  },
+  {
+    id: "vercel:project:add",
+    tool: "vercel",
+    base: ["project", "add"],
+    label: "project add",
+    hint: "Add a project"
+  },
+  {
+    id: "vercel:project:rm",
+    tool: "vercel",
+    base: ["project", "rm"],
+    label: "project rm",
+    hint: "Remove a project"
+  },
+  // Setup
+  {
+    id: "vercel:link",
+    tool: "vercel",
+    base: ["link"],
+    label: "link",
+    hint: "Link to a Vercel project"
+  },
+  {
+    id: "vercel:login",
+    tool: "vercel",
+    base: ["login"],
+    label: "login",
+    hint: "Log in to Vercel"
+  },
+  {
+    id: "vercel:whoami",
+    tool: "vercel",
+    base: ["whoami"],
+    label: "whoami",
+    hint: "Show current user"
+  },
+  // Logs & Inspect
+  {
+    id: "vercel:logs",
+    tool: "vercel",
+    base: ["logs"],
+    label: "logs",
+    hint: "View deployment logs"
+  },
+  {
+    id: "vercel:inspect",
+    tool: "vercel",
+    base: ["inspect"],
+    label: "inspect",
+    hint: "Inspect a deployment"
+  },
+  {
+    id: "vercel:ls",
+    tool: "vercel",
+    base: ["ls"],
+    label: "ls",
+    hint: "List deployments"
+  }
+];
+
+// src/data/commands/pulumi.ts
+var pulumiCommands = [
+  // Stack Management
+  { id: "pulumi:stack:ls", tool: "pulumi", base: ["stack", "ls"], label: "stack ls", hint: "List stacks" },
+  { id: "pulumi:stack:select", tool: "pulumi", base: ["stack", "select"], label: "stack select", hint: "Switch to a stack" },
+  { id: "pulumi:stack:init", tool: "pulumi", base: ["stack", "init"], label: "stack init", hint: "Create a new stack" },
+  { id: "pulumi:stack:rm", tool: "pulumi", base: ["stack", "rm"], label: "stack rm", hint: "Remove a stack" },
+  { id: "pulumi:stack:output", tool: "pulumi", base: ["stack", "output"], label: "stack output", hint: "Show stack outputs" },
+  // Core Operations
+  { id: "pulumi:up", tool: "pulumi", base: ["up"], label: "up", hint: "Deploy infrastructure changes" },
+  { id: "pulumi:preview", tool: "pulumi", base: ["preview"], label: "preview", hint: "Preview changes before deploying" },
+  { id: "pulumi:destroy", tool: "pulumi", base: ["destroy"], label: "destroy", hint: "Tear down all resources" },
+  { id: "pulumi:refresh", tool: "pulumi", base: ["refresh"], label: "refresh", hint: "Refresh state from cloud provider" },
+  // Config
+  { id: "pulumi:config:set", tool: "pulumi", base: ["config", "set"], label: "config set", hint: "Set a config value" },
+  { id: "pulumi:config:get", tool: "pulumi", base: ["config", "get"], label: "config get", hint: "Get a config value" },
+  { id: "pulumi:config:ls", tool: "pulumi", base: ["config"], label: "config", hint: "List config key-value pairs" },
+  // Import & State
+  { id: "pulumi:import", tool: "pulumi", base: ["import"], label: "import", hint: "Import existing resources" },
+  { id: "pulumi:state:delete", tool: "pulumi", base: ["state", "delete"], label: "state delete", hint: "Remove resource from state" },
+  // Auth & Setup
+  { id: "pulumi:login", tool: "pulumi", base: ["login"], label: "login", hint: "Log in to Pulumi Cloud" },
+  { id: "pulumi:whoami", tool: "pulumi", base: ["whoami"], label: "whoami", hint: "Show current user" },
+  { id: "pulumi:new", tool: "pulumi", base: ["new"], label: "new", hint: "Create a new project from template" },
+  // Editor-backed commands
+  { id: "pulumi:edit:config", tool: "pulumi", base: ["__editor__"], label: "edit config", hint: "Open Pulumi.yaml in editor", editorTarget: "config" },
+  { id: "pulumi:edit:code", tool: "pulumi", base: ["__editor__"], label: "edit code", hint: "Open IaC source file in editor", editorTarget: "code" }
+];
+
+// src/data/commands/index.ts
+var allCommands = [
+  ...supabaseCommands,
+  ...ghCommands,
+  ...vercelCommands,
+  ...pulumiCommands
+];
+var commandById = new Map(allCommands.map((cmd) => [cmd.id, cmd]));
+var commandByValue = new Map(
+  allCommands.map((cmd) => [getCommandValue(cmd), cmd])
+);
+function getCommandById(id) {
+  return commandById.get(id);
+}
+function getCommandsByTool(tool) {
+  return allCommands.filter((cmd) => cmd.tool === tool);
+}
+function getCommandValue(cmd) {
+  if (cmd.tool === "supabase") {
+    return cmd.base.join(" ");
+  }
+  return `${cmd.tool}:${cmd.base.join(" ")}`;
+}
+function findCommandByValue(value) {
+  const byId = commandById.get(value);
+  if (byId) return byId;
+  return commandByValue.get(value);
+}
+
+// src/data/features.ts
+function pick(ids) {
+  const idSet = new Set(ids);
+  return [...supabaseCommands, ...ghCommands, ...vercelCommands, ...pulumiCommands].filter(
+    (cmd) => idSet.has(cmd.id)
+  );
+}
+var features = [
+  {
+    id: "database",
+    icon: "\u{1F5C4}",
+    label: "Database",
+    commands: pick([
+      "supabase:db",
+      "supabase:migration",
+      "supabase:seed",
+      "supabase:inspect"
+    ])
+  },
+  {
+    id: "functions",
+    icon: "\u26A1",
+    label: "Functions",
+    commands: pick([
+      "supabase:functions"
+    ])
+  },
+  {
+    id: "deploy",
+    icon: "\u{1F680}",
+    label: "Deploy",
+    commands: pick([
+      "supabase:db",
+      "supabase:functions",
+      "vercel:deploy",
+      "vercel:deploy:prod",
+      "vercel:promote",
+      "vercel:rollback",
+      "pulumi:up",
+      "pulumi:preview"
+    ])
+  },
+  {
+    id: "repo",
+    icon: "\u{1F4E6}",
+    label: "Repo",
+    commands: pick([
+      "gh:repo:clone",
+      "gh:repo:create",
+      "gh:repo:view",
+      "gh:repo:list",
+      "gh:pr:create",
+      "gh:pr:list",
+      "gh:pr:view",
+      "gh:pr:merge",
+      "gh:pr:checkout",
+      "gh:issue:create",
+      "gh:issue:list",
+      "gh:issue:view",
+      "gh:issue:close",
+      "gh:release:create",
+      "gh:release:list",
+      "gh:release:view"
+    ])
+  },
+  {
+    id: "cicd",
+    icon: "\u{1F504}",
+    label: "CI/CD",
+    commands: pick([
+      "vercel:env:ls",
+      "vercel:env:add",
+      "vercel:env:rm",
+      "vercel:env:pull",
+      "gh:workflow:list",
+      "gh:workflow:run",
+      "gh:workflow:view",
+      "gh:run:list",
+      "gh:run:view",
+      "gh:run:watch",
+      "pulumi:preview",
+      "pulumi:up"
+    ])
+  },
+  {
+    id: "auth-storage",
+    icon: "\u{1F510}",
+    label: "Auth & Storage",
+    commands: pick([
+      "supabase:storage",
+      "supabase:secrets",
+      "supabase:sso"
+    ])
+  },
+  {
+    id: "networking",
+    icon: "\u{1F310}",
+    label: "Networking",
+    commands: pick([
+      "supabase:domains",
+      "supabase:ssl-enforcement",
+      "supabase:network-bans",
+      "supabase:network-restrictions",
+      "supabase:vanity-subdomains",
+      "supabase:encryption",
+      "vercel:domains:list",
+      "vercel:domains:add",
+      "vercel:domains:rm"
+    ])
+  },
+  {
+    id: "infrastructure",
+    icon: "\u{1F3D7}",
+    label: "Infrastructure",
+    commands: pick([
+      "pulumi:up",
+      "pulumi:preview",
+      "pulumi:destroy",
+      "pulumi:refresh",
+      "pulumi:stack:ls",
+      "pulumi:stack:select",
+      "pulumi:stack:init",
+      "pulumi:config:set",
+      "pulumi:config:get",
+      "pulumi:config:ls",
+      "pulumi:import",
+      "pulumi:state:delete",
+      "pulumi:edit:config",
+      "pulumi:edit:code"
+    ])
+  },
+  {
+    id: "setup",
+    icon: "\u2699\uFE0F",
+    label: "Setup",
+    commands: pick([
+      "supabase:init",
+      "supabase:link",
+      "supabase:login",
+      "vercel:link",
+      "vercel:login",
+      "gh:auth:login",
+      "gh:auth:status",
+      "pulumi:login",
+      "pulumi:whoami",
+      "pulumi:new"
+    ])
+  }
+];
+var featureById = new Map(features.map((f) => [f.id, f]));
+function getFeatureById(id) {
+  return featureById.get(id);
+}
+
+// src/data/flags.ts
+var globalFlags = [
+  { value: "--debug", label: "--debug", hint: "Output debug logs to stderr" },
+  { value: "--yes", label: "--yes", hint: "Answer yes to all prompts" },
+  {
+    value: "--create-ticket",
+    label: "--create-ticket",
+    hint: "Create support ticket on error"
+  },
+  {
+    value: "--experimental",
+    label: "--experimental",
+    hint: "Enable experimental features"
+  }
+];
+var toolFlags = {
+  supabase: globalFlags,
+  gh: [],
+  vercel: [
+    { value: "--yes", label: "--yes", hint: "Skip confirmation prompts" },
+    { value: "--debug", label: "--debug", hint: "Debug mode" }
+  ],
+  pulumi: [
+    { value: "--yes", label: "--yes", hint: "Skip confirmation prompts" },
+    { value: "--debug", label: "--debug", hint: "Debug mode" },
+    { value: "--stack", label: "--stack", hint: "Target a specific stack" }
+  ]
+};
+function getFlagsForTool(toolId) {
+  return toolFlags[toolId] ?? globalFlags;
+}
+
+// src/lib/runner.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { delimiter, dirname, join, resolve } from "path";
+function getSupabaseBinaryCandidates() {
+  if (process.platform === "win32") {
+    return ["supabase.cmd", "supabase.exe", "supabase"];
+  }
+  return ["supabase"];
+}
+function hasLocalSupabaseBinary(binDir) {
+  return getSupabaseBinaryCandidates().some(
+    (candidate) => existsSync(join(binDir, candidate))
+  );
+}
+function getPathEnvKey(env) {
+  return Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+}
+function findLocalSupabaseBinDir(startDir = process.cwd()) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    const binDir = join(currentDir, "node_modules", ".bin");
+    if (hasLocalSupabaseBinary(binDir)) {
+      return binDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveSupabaseCommand(startDir = process.cwd(), env = process.env) {
+  const localBinDir = findLocalSupabaseBinDir(startDir);
+  if (!localBinDir) {
+    return {
+      command: "supabase",
+      env: { ...env },
+      source: "path"
+    };
+  }
+  const pathKey = getPathEnvKey(env);
+  const currentPath = env[pathKey];
+  return {
+    command: "supabase",
+    env: {
+      ...env,
+      [pathKey]: currentPath ? `${localBinDir}${delimiter}${currentPath}` : localBinDir
+    },
+    source: "repository",
+    localBinDir
+  };
+}
+async function runCommand(execution, args, cwd = process.cwd(), options) {
+  return new Promise((resolve3) => {
+    let stdout = "";
+    let stderr = "";
+    const resolvedExecution = typeof execution === "string" ? { command: execution } : execution;
+    const child = spawn(resolvedExecution.command, args, {
+      cwd,
+      env: resolvedExecution.env,
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      if (!options?.quiet) process.stdout.write(text);
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      if (!options?.quiet) process.stderr.write(text);
+    });
+    child.on("error", (err) => {
+      resolve3({
+        exitCode: null,
+        signal: null,
+        stdout,
+        stderr,
+        spawnError: err.message
+      });
+    });
+    child.on("exit", (code, signal) => {
+      resolve3({ exitCode: code, signal, stdout, stderr });
+    });
+  });
+}
+async function runSupabaseCommand(args, cwd = process.cwd()) {
+  return runCommand(resolveSupabaseCommand(cwd), args, cwd);
+}
+
+// src/lib/system.ts
+import { execSync } from "child_process";
+function commandExists(command) {
+  try {
+    execSync(`command -v ${command}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function execCapture(command) {
+  return execSync(command, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+
+// src/lib/toolResolver.ts
+function resolveToolCommand(toolId, cwd = process.cwd()) {
+  if (toolId === "supabase") {
+    const resolved = resolveSupabaseCommand(cwd);
+    return {
+      command: resolved.command,
+      env: resolved.env,
+      source: resolved.source
+    };
+  }
+  const command = toolId;
+  if (!commandExists(command)) {
+    return { command, source: "not-found" };
+  }
+  return { command, env: { ...process.env }, source: "path" };
+}
+function getToolVersion(toolId) {
+  try {
+    switch (toolId) {
+      case "supabase":
+        return execCapture("supabase --version").replace(/^supabase\s+/i, "");
+      case "gh":
+        return execCapture("gh --version").split("\n")[0]?.replace(/^gh\s+version\s+/i, "").split(" ")[0];
+      case "vercel":
+        return execCapture("vercel --version").split("\n")[0]?.trim();
+      case "pulumi":
+        return execCapture("pulumi version").replace(/^v/, "");
+      default:
+        return void 0;
+    }
+  } catch {
+    return void 0;
+  }
+}
+var toolInfoCache = /* @__PURE__ */ new Map();
+function getToolInfo(toolId) {
+  const cached = toolInfoCache.get(toolId);
+  if (cached) return cached;
+  const labels = {
+    supabase: "Supabase CLI",
+    gh: "GitHub CLI",
+    vercel: "Vercel CLI",
+    pulumi: "Pulumi CLI"
+  };
+  const installed = commandExists(toolId === "supabase" ? "supabase" : toolId);
+  const version = installed ? getToolVersion(toolId) : void 0;
+  const info = {
+    id: toolId,
+    label: labels[toolId],
+    installed,
+    version
+  };
+  toolInfoCache.set(toolId, info);
+  return info;
+}
+
+// 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" };
+    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
+    const cmdDef = getCommandById(step.commandId);
+    const toolId = cmdDef?.tool ?? "supabase";
+    const resolved = resolveToolCommand(toolId, cwd);
+    const baseArgs = cmdDef?.base ?? [];
+    const allArgs = [...baseArgs, ...step.args, ...step.flags];
+    const result = await runCommand(
+      { command: resolved.command, env: resolved.env },
+      allArgs,
+      cwd
+    );
+    const success = !result.spawnError && result.exitCode === 0;
+    stepResults[i] = {
+      step,
+      status: success ? "success" : "error",
+      result
+    };
+    if (!success && !step.continueOnError) {
+      aborted = true;
+    }
+    onProgress({ stepResults: [...stepResults], currentStepIndex: i, done: false });
+  }
+  onProgress({
+    stepResults: [...stepResults],
+    currentStepIndex: pipeline.steps.length - 1,
+    done: true
+  });
+  return stepResults;
+}
+
+// src/config/projectConfig.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/packageRoot.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+var rootCache = /* @__PURE__ */ new Map();
+function findNearestPackageRoot(startDir = process.cwd()) {
+  const resolvedStart = resolve2(startDir);
+  if (rootCache.has(resolvedStart)) return rootCache.get(resolvedStart);
+  let currentDir = resolvedStart;
+  while (true) {
+    if (existsSync2(join2(currentDir, "package.json"))) {
+      rootCache.set(resolvedStart, currentDir);
+      return currentDir;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      rootCache.set(resolvedStart, void 0);
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// src/config/projectConfig.ts
+var CONFIG_DIR = ".polter";
+var CONFIG_FILE = "config.json";
+function defaultConfig() {
+  return {
+    version: 1,
+    tools: {},
+    pipelines: []
+  };
+}
+function getProjectConfigPath(startDir) {
+  const root = findNearestPackageRoot(startDir);
+  if (!root) return void 0;
+  const dir = join3(root, CONFIG_DIR);
+  return { dir, file: join3(dir, CONFIG_FILE) };
+}
+function readProjectConfig(startDir) {
+  const paths = getProjectConfigPath(startDir);
+  if (!paths) return void 0;
+  if (!existsSync3(paths.file)) return void 0;
+  try {
+    const raw = readFileSync(paths.file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function writeProjectConfig(config2, startDir) {
+  const paths = getProjectConfigPath(startDir);
+  if (!paths) return false;
+  mkdirSync(paths.dir, { recursive: true });
+  writeFileSync(paths.file, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  return true;
+}
+function getOrCreateProjectConfig(startDir) {
+  return readProjectConfig(startDir) ?? defaultConfig();
+}
+function getProjectPipelines(startDir) {
+  const config2 = readProjectConfig(startDir);
+  return config2?.pipelines ?? [];
+}
+function saveProjectPipeline(pipeline, startDir) {
+  const config2 = getOrCreateProjectConfig(startDir);
+  const idx = config2.pipelines.findIndex((p) => p.id === pipeline.id);
+  if (idx >= 0) {
+    config2.pipelines[idx] = pipeline;
+  } else {
+    config2.pipelines.push(pipeline);
+  }
+  return writeProjectConfig(config2, startDir);
+}
+function deleteProjectPipeline(pipelineId, startDir) {
+  const config2 = getOrCreateProjectConfig(startDir);
+  config2.pipelines = config2.pipelines.filter((p) => p.id !== pipelineId);
+  return writeProjectConfig(config2, startDir);
+}
+
+// src/config/store.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: process.env.NODE_ENV === "test" ? "polter-test" : "polter"
+});
+var GLOBAL_PIPELINES_KEY = "globalPipelinesV1";
+function getGlobalPipelines() {
+  if (!config.has(GLOBAL_PIPELINES_KEY)) {
+    config.set(GLOBAL_PIPELINES_KEY, []);
+  }
+  return config.get(GLOBAL_PIPELINES_KEY) || [];
+}
+function saveGlobalPipeline(pipeline) {
+  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 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") {
+    saveProjectPipeline(pipeline, startDir);
+  } else {
+    saveGlobalPipeline(pipeline);
+  }
+}
+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);
+}
+
+// src/declarative/parser.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+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 = join4(startDir, YAML_FILE);
+  return existsSync4(filePath) ? filePath : void 0;
+}
+function parsePolterYaml(startDir = process.cwd()) {
+  const filePath = findPolterYaml(startDir);
+  if (!filePath) return void 0;
+  const content = readFileSync2(filePath, "utf-8");
+  const raw = parseSimpleYaml(content);
+  return raw;
+}
+
+// src/declarative/status.ts
+import { execSync as execSync2 } from "child_process";
+function safeExec(cmd) {
+  try {
+    return execSync2(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;
+}
+
+// src/declarative/planner.ts
+function planChanges(desired, cwd = process.cwd()) {
+  const current = getCurrentStatus(cwd);
+  const actions = [];
+  if (desired.supabase?.functions) {
+    const currentFunctions = new Set(current.supabase?.functions ?? []);
+    for (const fn of desired.supabase.functions) {
+      if (!currentFunctions.has(fn.name)) {
+        const args = ["functions", "deploy", fn.name];
+        if (fn.verify_jwt === false) {
+          args.push("--no-verify-jwt");
+        }
+        actions.push({
+          tool: "supabase",
+          action: "create",
+          resource: `function:${fn.name}`,
+          description: `Deploy function "${fn.name}"`,
+          args
+        });
+      }
+    }
+  }
+  if (desired.supabase?.secrets) {
+    for (const secret of desired.supabase.secrets) {
+      actions.push({
+        tool: "supabase",
+        action: "update",
+        resource: `secret:${secret}`,
+        description: `Ensure secret "${secret}" is set`,
+        args: ["secrets", "set", secret]
+      });
+    }
+  }
+  if (desired.vercel?.domains) {
+    for (const domain of desired.vercel.domains) {
+      actions.push({
+        tool: "vercel",
+        action: "create",
+        resource: `domain:${domain}`,
+        description: `Add domain "${domain}"`,
+        args: ["domains", "add", domain]
+      });
+    }
+  }
+  if (desired.vercel?.env) {
+    for (const [env, vars] of Object.entries(desired.vercel.env)) {
+      for (const [key, value] of Object.entries(vars)) {
+        actions.push({
+          tool: "vercel",
+          action: "update",
+          resource: `env:${env}:${key}`,
+          description: `Set env var "${key}" for ${env}`,
+          args: ["env", "add", key, env]
+        });
+      }
+    }
+  }
+  if (desired.github?.secrets) {
+    for (const secret of desired.github.secrets) {
+      actions.push({
+        tool: "gh",
+        action: "update",
+        resource: `secret:${secret}`,
+        description: `Ensure GitHub secret "${secret}" is set`,
+        args: ["secret", "set", secret]
+      });
+    }
+  }
+  return {
+    actions,
+    noChanges: actions.length === 0
+  };
+}
+
+// src/declarative/applier.ts
+async function applyActions(actions, cwd = process.cwd(), onProgress) {
+  const results = [];
+  for (let i = 0; i < actions.length; i++) {
+    const action = actions[i];
+    onProgress?.(i, actions.length, action);
+    const resolved = resolveToolCommand(action.tool, cwd);
+    const result = await runCommand(
+      { command: resolved.command, env: resolved.env },
+      action.args,
+      cwd
+    );
+    const success = !result.spawnError && result.exitCode === 0;
+    results.push({ action, success, result });
+  }
+  return results;
+}
+
+export {
+  __export,
+  allCommands,
+  getCommandById,
+  getCommandsByTool,
+  getCommandValue,
+  findCommandByValue,
+  features,
+  getFeatureById,
+  toolFlags,
+  getFlagsForTool,
+  runCommand,
+  runSupabaseCommand,
+  commandExists,
+  resolveToolCommand,
+  getToolInfo,
+  executePipeline,
+  findNearestPackageRoot,
+  getProjectConfigPath,
+  writeProjectConfig,
+  getOrCreateProjectConfig,
+  getAllPipelines,
+  savePipeline,
+  deletePipeline,
+  findPipelineByName,
+  parsePolterYaml,
+  getCurrentStatus,
+  planChanges,
+  applyActions
+};