@stackweld/cli 0.2.0

package/dist/commands/browse.js

@@ -0,0 +1,101 @@
+/**
+ * stackweld browse — Browse the technology catalog and templates.
+ */
+import { select } from "@inquirer/prompts";
+import { getAllTemplates } from "@stackweld/templates";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine } from "../ui/context.js";
+import { emptyState, formatJson, formatTechTable, formatTemplate, sectionHeader, } from "../ui/format.js";
+export const browseCommand = new Command("browse")
+    .description("Browse the technology catalog and templates")
+    .option("--category <cat>", "Filter by category")
+    .option("--templates", "Show templates only")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+    const rules = getRulesEngine();
+    if (opts.templates) {
+        const templates = getAllTemplates();
+        if (opts.json) {
+            console.log(formatJson(templates));
+            return;
+        }
+        if (templates.length === 0) {
+            console.log(emptyState("No templates available."));
+            return;
+        }
+        console.log(chalk.bold(`\n  ${templates.length} template(s)\n`));
+        for (const t of templates) {
+            console.log(formatTemplate(t));
+            console.log("");
+        }
+        return;
+    }
+    const categories = [
+        "runtime",
+        "frontend",
+        "backend",
+        "database",
+        "orm",
+        "auth",
+        "styling",
+        "service",
+        "devops",
+    ];
+    const category = opts.category ||
+        (await select({
+            message: "Browse by category:",
+            choices: [
+                { name: "All technologies", value: "all" },
+                ...categories.map((c) => ({ name: c, value: c })),
+                { name: "Templates", value: "templates" },
+            ],
+        }));
+    if (category === "templates") {
+        const templates = getAllTemplates();
+        if (opts.json) {
+            console.log(formatJson(templates));
+            return;
+        }
+        if (templates.length === 0) {
+            console.log(emptyState("No templates available."));
+            return;
+        }
+        for (const t of templates) {
+            console.log(formatTemplate(t));
+            console.log("");
+        }
+        return;
+    }
+    if (category === "all") {
+        // Show all technologies grouped by category
+        const allTechs = rules.getAllTechnologies();
+        if (opts.json) {
+            console.log(formatJson(allTechs));
+            return;
+        }
+        console.log(chalk.bold(`\n  ${allTechs.length} technologies in catalog\n`));
+        for (const cat of categories) {
+            const techs = rules.getByCategory(cat);
+            if (techs.length === 0)
+                continue;
+            console.log(sectionHeader(`  ${cat.toUpperCase()} (${techs.length})`));
+            console.log(formatTechTable(techs));
+            console.log("");
+        }
+        return;
+    }
+    const techs = rules.getByCategory(category);
+    if (opts.json) {
+        console.log(formatJson(techs));
+        return;
+    }
+    if (techs.length === 0) {
+        console.log(emptyState("No technologies in this category."));
+        return;
+    }
+    console.log(chalk.bold(`\n  ${techs.length} ${category} technology(ies)\n`));
+    console.log(formatTechTable(techs));
+    console.log("");
+});
+//# sourceMappingURL=browse.js.map

package/dist/commands/clone.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const cloneCommand: Command;
+//# sourceMappingURL=clone.d.ts.map

package/dist/commands/clone.js

@@ -0,0 +1,37 @@
+import { input } from "@inquirer/prompts";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { formatStackRow } from "../ui/format.js";
+export const cloneCommand = new Command("clone")
+    .description("Duplicate a saved stack")
+    .argument("<stack-id>", "Stack ID to clone")
+    .option("--name <name>", "Name for the cloned stack")
+    .action(async (stackId, opts) => {
+    const engine = getStackEngine();
+    const source = engine.get(stackId);
+    if (!source) {
+        console.error(chalk.red(`Stack "${stackId}" not found.`));
+        process.exit(1);
+    }
+    const name = opts.name ||
+        (await input({
+            message: "Name for the cloned stack:",
+            default: `${source.name} (copy)`,
+        }));
+    const { stack, validation } = engine.create({
+        name,
+        description: source.description,
+        profile: source.profile,
+        technologies: source.technologies,
+        tags: [...source.tags, "cloned"],
+    });
+    if (validation.valid) {
+        console.log(chalk.green(`✓ Cloned "${source.name}" as "${name}"`));
+        console.log(formatStackRow(stack));
+    }
+    else {
+        console.error(chalk.red("Clone failed validation."));
+    }
+});
+//# sourceMappingURL=clone.js.map

package/dist/commands/compare.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld compare <stackA> <stackB> — Compare two saved stacks side by side.
+ */
+import { Command } from "commander";
+export declare const compareCommand: Command;
+//# sourceMappingURL=compare.d.ts.map

package/dist/commands/compare.js

@@ -0,0 +1,93 @@
+/**
+ * stackweld compare <stackA> <stackB> — Compare two saved stacks side by side.
+ */
+import { diffStacks } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { box, formatJson, gradientHeader } from "../ui/format.js";
+export const compareCommand = new Command("compare")
+    .description("Compare two saved stacks")
+    .argument("<stackA>", "First stack ID")
+    .argument("<stackB>", "Second stack ID")
+    .option("--json", "Output as JSON")
+    .action((stackAId, stackBId, opts) => {
+    const engine = getStackEngine();
+    const stackA = engine.get(stackAId);
+    if (!stackA) {
+        console.error(chalk.red(`\u2716 Stack "${stackAId}" not found.`));
+        console.error(chalk.dim("  Run `stackweld list` to see available stacks."));
+        process.exit(1);
+    }
+    const stackB = engine.get(stackBId);
+    if (!stackB) {
+        console.error(chalk.red(`\u2716 Stack "${stackBId}" not found.`));
+        console.error(chalk.dim("  Run `stackweld list` to see available stacks."));
+        process.exit(1);
+    }
+    const diff = diffStacks(stackA, stackB);
+    if (opts.json) {
+        console.log(formatJson({
+            stackA: { id: stackA.id, name: stackA.name },
+            stackB: { id: stackB.id, name: stackB.name },
+            ...diff,
+        }));
+        return;
+    }
+    const lines = [];
+    lines.push("");
+    // Added
+    if (diff.added.length > 0) {
+        lines.push(chalk.green.bold(`  + Added in B (${diff.added.length}):`));
+        for (const item of diff.added) {
+            const ver = item.version ? ` ${item.version}` : "";
+            lines.push(chalk.green(`    + ${item.name}${ver}`));
+        }
+        lines.push("");
+    }
+    // Removed
+    if (diff.removed.length > 0) {
+        lines.push(chalk.red.bold(`  - Removed from A (${diff.removed.length}):`));
+        for (const item of diff.removed) {
+            const ver = item.version ? ` ${item.version}` : "";
+            lines.push(chalk.red(`    - ${item.name}${ver}`));
+        }
+        lines.push("");
+    }
+    // Changed
+    if (diff.changed.length > 0) {
+        // Group changes by technology
+        const byTech = new Map();
+        for (const change of diff.changed) {
+            const existing = byTech.get(change.technologyId) || [];
+            existing.push(change);
+            byTech.set(change.technologyId, existing);
+        }
+        lines.push(chalk.yellow.bold(`  ~ Changed (${byTech.size}):`));
+        for (const [, changes] of byTech) {
+            for (const change of changes) {
+                lines.push(chalk.yellow(`    ~ ${change.name}: ${change.from} \u2192 ${change.to}`) +
+                    chalk.dim(` (${change.field})`));
+            }
+        }
+        lines.push("");
+    }
+    // Unchanged
+    if (diff.unchanged.length > 0) {
+        lines.push(chalk.dim(`  = Unchanged (${diff.unchanged.length}):`));
+        lines.push(chalk.dim(`    ${diff.unchanged.join(", ")}`));
+        lines.push("");
+    }
+    // No differences
+    if (diff.added.length === 0 && diff.removed.length === 0 && diff.changed.length === 0) {
+        lines.push(chalk.green("  Stacks are identical."));
+        lines.push("");
+    }
+    lines.push(`  ${chalk.dim("Summary:")} ${diff.summary}`);
+    lines.push("");
+    const title = `A: ${stackA.name}  vs  B: ${stackB.name}`;
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Stack Comparison")}\n`);
+    console.log(box(lines.join("\n"), title));
+    console.log("");
+});
+//# sourceMappingURL=compare.js.map

package/dist/commands/completion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld completion — Generate shell completions.
+ */
+import { Command } from "commander";
+export declare const completionCommand: Command;
+//# sourceMappingURL=completion.d.ts.map

package/dist/commands/completion.js

@@ -0,0 +1,86 @@
+/**
+ * stackweld completion — Generate shell completions.
+ */
+import { Command } from "commander";
+const BASH_COMPLETION = `
+# stackweld bash completion
+_stackweld_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local commands="init create list info save export import browse doctor delete version up down status logs scaffold completion"
+
+  if [ "\${COMP_CWORD}" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+  fi
+}
+complete -F _stackweld_completions stackweld
+`.trim();
+const ZSH_COMPLETION = `
+#compdef stackweld
+
+_stackweld() {
+  local -a commands
+  commands=(
+    'init:Create a new stack interactively'
+    'create:Scaffold a project from a stack or template'
+    'list:List all saved stacks'
+    'info:Show details about a stack or technology'
+    'save:Save a version snapshot of a stack'
+    'export:Export a stack definition to YAML or JSON'
+    'import:Import a stack definition from a file'
+    'browse:Browse the technology catalog and templates'
+    'doctor:Check system requirements and environment'
+    'delete:Delete a saved stack'
+    'version:Manage stack versions'
+    'up:Start Docker services'
+    'down:Stop Docker services'
+    'status:Show status of running services'
+    'logs:Show logs from Docker services'
+    'scaffold:Generate project files from a stack'
+    'completion:Generate shell completions'
+  )
+
+  _describe 'command' commands
+}
+
+_stackweld
+`.trim();
+const FISH_COMPLETION = `
+# stackweld fish completions
+complete -c stackweld -n "__fish_use_subcommand" -a init -d "Create a new stack interactively"
+complete -c stackweld -n "__fish_use_subcommand" -a create -d "Scaffold a project"
+complete -c stackweld -n "__fish_use_subcommand" -a list -d "List all saved stacks"
+complete -c stackweld -n "__fish_use_subcommand" -a info -d "Show details about a stack or technology"
+complete -c stackweld -n "__fish_use_subcommand" -a save -d "Save a version snapshot"
+complete -c stackweld -n "__fish_use_subcommand" -a export -d "Export a stack definition"
+complete -c stackweld -n "__fish_use_subcommand" -a import -d "Import a stack definition"
+complete -c stackweld -n "__fish_use_subcommand" -a browse -d "Browse the technology catalog"
+complete -c stackweld -n "__fish_use_subcommand" -a doctor -d "Check system requirements"
+complete -c stackweld -n "__fish_use_subcommand" -a delete -d "Delete a saved stack"
+complete -c stackweld -n "__fish_use_subcommand" -a version -d "Manage stack versions"
+complete -c stackweld -n "__fish_use_subcommand" -a up -d "Start Docker services"
+complete -c stackweld -n "__fish_use_subcommand" -a down -d "Stop Docker services"
+complete -c stackweld -n "__fish_use_subcommand" -a status -d "Show status of running services"
+complete -c stackweld -n "__fish_use_subcommand" -a logs -d "Show logs from Docker services"
+complete -c stackweld -n "__fish_use_subcommand" -a scaffold -d "Generate project files"
+complete -c stackweld -n "__fish_use_subcommand" -a completion -d "Generate shell completions"
+`.trim();
+export const completionCommand = new Command("completion")
+    .description("Generate shell completion scripts")
+    .argument("<shell>", "Shell type: bash, zsh, or fish")
+    .action((shell) => {
+    switch (shell) {
+        case "bash":
+            console.log(BASH_COMPLETION);
+            break;
+        case "zsh":
+            console.log(ZSH_COMPLETION);
+            break;
+        case "fish":
+            console.log(FISH_COMPLETION);
+            break;
+        default:
+            console.error(`Unknown shell: ${shell}. Use bash, zsh, or fish.`);
+            process.exit(1);
+    }
+});
+//# sourceMappingURL=completion.js.map

package/dist/commands/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld config — Manage user preferences.
+ */
+import { Command } from "commander";
+export declare const configCommand: Command;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.js

@@ -0,0 +1,56 @@
+/**
+ * stackweld config — Manage user preferences.
+ */
+import { getDefaultPreferences, getPreferenceKeys, getPreferences, resetPreferences, setPreference, } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { formatJson } from "../ui/format.js";
+export const configCommand = new Command("config")
+    .description("Manage user preferences")
+    .addCommand(new Command("list")
+    .description("Show all preferences")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const prefs = getPreferences();
+    const defaults = getDefaultPreferences();
+    if (opts.json) {
+        console.log(formatJson(prefs));
+        return;
+    }
+    console.log(chalk.bold("Preferences:\n"));
+    for (const key of getPreferenceKeys()) {
+        const value = prefs[key];
+        const isDefault = value === defaults[key];
+        console.log(`  ${chalk.cyan(key)}: ${value} ${isDefault ? chalk.dim("(default)") : ""}`);
+    }
+}))
+    .addCommand(new Command("set")
+    .description("Set a preference")
+    .argument("<key>", "Preference key")
+    .argument("<value>", "Preference value")
+    .action((key, value) => {
+    const validKeys = getPreferenceKeys();
+    if (!validKeys.includes(key)) {
+        console.error(chalk.red(`Invalid key "${key}". Valid keys: ${validKeys.join(", ")}`));
+        process.exit(1);
+    }
+    setPreference(key, value);
+    console.log(chalk.green(`✓ Set ${key} = ${value}`));
+}))
+    .addCommand(new Command("get")
+    .description("Get a preference value")
+    .argument("<key>", "Preference key")
+    .action((key) => {
+    const prefs = getPreferences();
+    const validKeys = getPreferenceKeys();
+    if (!validKeys.includes(key)) {
+        console.error(chalk.red(`Invalid key "${key}".`));
+        process.exit(1);
+    }
+    console.log(prefs[key]);
+}))
+    .addCommand(new Command("reset").description("Reset all preferences to defaults").action(() => {
+    resetPreferences();
+    console.log(chalk.green("✓ Preferences reset to defaults."));
+}));
+//# sourceMappingURL=config.js.map

package/dist/commands/cost.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld cost <stackId> — Estimate monthly hosting costs for a saved stack.
+ */
+import { Command } from "commander";
+export declare const costCommand: Command;
+//# sourceMappingURL=cost.d.ts.map

package/dist/commands/cost.js

@@ -0,0 +1,101 @@
+/**
+ * stackweld cost <stackId> — Estimate monthly hosting costs for a saved stack.
+ */
+import { estimateCost } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { box, formatJson, gradientHeader, table } from "../ui/format.js";
+const TIER_COLORS = {
+    free: (s) => chalk.green.bold(s),
+    budget: (s) => chalk.cyan.bold(s),
+    standard: (s) => chalk.yellow.bold(s),
+    premium: (s) => chalk.magenta.bold(s),
+};
+const TIER_ICONS = {
+    free: "\u2728",
+    budget: "\uD83D\uDCB0",
+    standard: "\uD83D\uDCB3",
+    premium: "\uD83D\uDC8E",
+};
+export const costCommand = new Command("cost")
+    .description("Estimate monthly hosting costs for a saved stack")
+    .argument("<stack-id>", "Stack ID to estimate costs for")
+    .option("--json", "Output as JSON")
+    .action((stackId, opts) => {
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(chalk.red(`\u2716 Stack "${stackId}" not found.`));
+        console.error(chalk.dim("  Run: stackweld list"));
+        process.exit(1);
+    }
+    // Resolve full technology data
+    const technologies = stack.technologies
+        .map((st) => rules.getTechnology(st.technologyId))
+        .filter((t) => t !== undefined);
+    if (technologies.length === 0) {
+        console.error(chalk.red("\u2716 No technologies could be resolved for this stack."));
+        process.exit(1);
+    }
+    const estimate = estimateCost(technologies);
+    if (opts.json) {
+        console.log(formatJson(estimate));
+        return;
+    }
+    // ── Format output ──
+    const tierColor = TIER_COLORS[estimate.tier] || chalk.white;
+    const tierIcon = TIER_ICONS[estimate.tier] || "";
+    const lines = [];
+    lines.push("");
+    // Cost range
+    const { min, max, currency } = estimate.monthly;
+    const rangeStr = min === max ? `$${min}/mo` : `$${min} - $${max}/mo`;
+    lines.push(`  ${chalk.dim("Estimated:")}  ${chalk.bold.green(rangeStr)} ${chalk.dim(`(${currency})`)}`);
+    lines.push(`  ${chalk.dim("Tier:")}       ${tierIcon} ${tierColor(estimate.tier.toUpperCase())}`);
+    lines.push("");
+    // Breakdown table
+    // Deduplicate by service+provider for display
+    const seen = new Set();
+    const uniqueItems = estimate.breakdown.filter((item) => {
+        const key = `${item.service}|${item.provider}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    const tableData = uniqueItems.map((item) => ({
+        service: item.service,
+        provider: item.provider,
+        cost: item.monthlyCost,
+        notes: item.notes.length > 35 ? `${item.notes.slice(0, 32)}...` : item.notes,
+    }));
+    if (tableData.length > 0) {
+        lines.push(`  ${chalk.bold("Cost Breakdown:")}`);
+        lines.push("");
+        const tbl = table(tableData, [
+            { header: "Service", key: "service", color: (v) => chalk.cyan(v) },
+            { header: "Provider", key: "provider" },
+            { header: "Cost", key: "cost", color: (v) => chalk.green(v) },
+            { header: "Notes", key: "notes", color: (v) => chalk.dim(v) },
+        ]);
+        // Indent table lines
+        for (const line of tbl.split("\n")) {
+            lines.push(`  ${line}`);
+        }
+        lines.push("");
+    }
+    // Notes
+    if (estimate.notes.length > 0) {
+        lines.push(`  ${chalk.bold("Notes:")}`);
+        for (const note of estimate.notes) {
+            lines.push(`  ${chalk.dim("\u2192")} ${chalk.dim(note)}`);
+        }
+        lines.push("");
+    }
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Cost Estimator")}\n`);
+    console.log(box(lines.join("\n"), `Cost Estimate: ${stack.name}`));
+    console.log("");
+});
+//# sourceMappingURL=cost.js.map

package/dist/commands/create.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stackweld create <stack-id> --path <dir> — Scaffold a stack to disk.
+ * Uses official CLI tools when available and fills gaps.
+ */
+import { Command } from "commander";
+export declare const createCommand: Command;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/create.js

@@ -0,0 +1,111 @@
+/**
+ * stackweld create <stack-id> --path <dir> — Scaffold a stack to disk.
+ * Uses official CLI tools when available and fills gaps.
+ */
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getAllTemplates, getTemplate } from "@stackweld/templates";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { getStackEngine } from "../ui/context.js";
+export const createCommand = new Command("create")
+    .description("Scaffold a project from a stack or template")
+    .argument("<id>", "Stack ID or template ID")
+    .option("-p, --path <dir>", "Target directory", ".")
+    .option("--dry-run", "Show what would be executed without doing it")
+    .option("--json", "Output result as JSON")
+    .action(async (id, opts) => {
+    const engine = getStackEngine();
+    // Check if it's a template
+    const template = getTemplate(id);
+    const stack = engine.get(id);
+    if (!template && !stack) {
+        console.error(chalk.red(`"${id}" is not a valid stack ID or template ID.`));
+        console.log(chalk.dim("Available templates: " +
+            getAllTemplates()
+                .map((t) => t.id)
+                .join(", ")));
+        process.exit(1);
+    }
+    if (template) {
+        console.log(chalk.cyan(`Using template: ${template.name}`));
+        const projectName = path.basename(opts.path === "." ? template.variables.projectName || "my-project" : opts.path);
+        const targetDir = path.resolve(opts.path === "." ? projectName : opts.path);
+        // Execute scaffold steps
+        for (const step of template.scaffoldSteps) {
+            const command = step.command.replace(/\{\{projectName\}\}/g, projectName);
+            const cwd = step.workingDir
+                ? path.resolve(step.workingDir.replace(/\{\{projectName\}\}/g, projectName))
+                : process.cwd();
+            if (opts.dryRun) {
+                console.log(chalk.dim(`[dry-run] ${step.name}: ${command}`));
+                continue;
+            }
+            const spinner = ora(step.name).start();
+            try {
+                execSync(command, { cwd, stdio: "pipe" });
+                spinner.succeed(step.name);
+            }
+            catch (err) {
+                spinner.fail(step.name);
+                console.error(chalk.red(`  Command failed: ${command}`));
+                if (err instanceof Error) {
+                    console.error(chalk.dim(err.message.slice(0, 200)));
+                }
+            }
+        }
+        // Apply overrides
+        for (const override of template.overrides) {
+            const filePath = path.join(targetDir, override.path.replace(/\{\{projectName\}\}/g, projectName));
+            if (opts.dryRun) {
+                console.log(chalk.dim(`[dry-run] Write: ${filePath}`));
+                continue;
+            }
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            const content = override.content.replace(/\{\{projectName\}\}/g, projectName);
+            fs.writeFileSync(filePath, content, "utf-8");
+            console.log(chalk.green(`  ✓ ${override.path}`));
+        }
+        // Execute hooks
+        for (const hook of template.hooks) {
+            const command = hook.command.replace(/\{\{projectName\}\}/g, projectName);
+            if (opts.dryRun) {
+                console.log(chalk.dim(`[dry-run] Hook (${hook.timing}): ${command}`));
+                continue;
+            }
+            if (hook.requiresConfirmation) {
+                console.log(chalk.yellow(`Hook requires confirmation: ${hook.description}`));
+                console.log(chalk.dim(`  Command: ${command}`));
+                // In a real implementation, we'd prompt for confirmation here
+                continue;
+            }
+            const spinner = ora(`${hook.timing}: ${hook.name}`).start();
+            try {
+                execSync(command, { stdio: "pipe" });
+                spinner.succeed(`${hook.timing}: ${hook.name}`);
+            }
+            catch {
+                spinner.fail(`${hook.timing}: ${hook.name}`);
+            }
+        }
+        if (!opts.dryRun) {
+            console.log("");
+            console.log(chalk.green(`✓ Project "${projectName}" created successfully!`));
+            console.log(chalk.dim(`  cd ${projectName}`));
+        }
+    }
+    else if (stack) {
+        if (opts.json) {
+            console.log(JSON.stringify(stack, null, 2));
+        }
+        else {
+            console.log(chalk.cyan(`Stack: ${stack.name}`));
+            console.log(chalk.dim("Scaffold orchestration for saved stacks is coming in the next release."));
+        }
+    }
+});
+//# sourceMappingURL=create.js.map

package/dist/commands/delete.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld delete <id> — Delete a saved stack.
+ */
+import { Command } from "commander";
+export declare const deleteCommand: Command;
+//# sourceMappingURL=delete.d.ts.map

package/dist/commands/delete.js

@@ -0,0 +1,33 @@
+/**
+ * stackweld delete <id> — Delete a saved stack.
+ */
+import { confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+export const deleteCommand = new Command("delete")
+    .aliases(["rm"])
+    .description("Delete a saved stack")
+    .argument("<id>", "Stack ID")
+    .option("-f, --force", "Skip confirmation")
+    .action(async (id, opts) => {
+    const engine = getStackEngine();
+    const stack = engine.get(id);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${id}" not found.`));
+        process.exit(1);
+    }
+    if (!opts.force) {
+        const yes = await confirm({
+            message: `Delete stack "${stack.name}"? This cannot be undone.`,
+            default: false,
+        });
+        if (!yes) {
+            console.log(chalk.dim("Cancelled."));
+            return;
+        }
+    }
+    engine.delete(id);
+    console.log(chalk.green(`✓ Stack "${stack.name}" deleted.`));
+});
+//# sourceMappingURL=delete.js.map