@stackweld/cli 0.2.0

package/dist/commands/share.js

@@ -0,0 +1,93 @@
+/**
+ * stackweld share <stackId> — Generate a shareable URL for a saved stack.
+ * stackweld import-url <url> — Import a stack from a share URL.
+ *
+ * Stack data is encoded in the URL hash — no server needed.
+ */
+import { deserializeStack, extractFromShareUrl, generateShareUrl, } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { box, formatStackRow, formatValidation, info } from "../ui/format.js";
+export const shareCommand = new Command("share")
+    .description("Generate a shareable URL for a saved stack")
+    .argument("<id>", "Stack ID")
+    .option("--base-url <url>", "Custom base URL", "https://stackweld.dev/s/#")
+    .action((id, opts) => {
+    const engine = getStackEngine();
+    const stack = engine.get(id);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${id}" not found.`));
+        process.exit(1);
+    }
+    const shareable = {
+        name: stack.name,
+        profile: stack.profile,
+        technologies: stack.technologies.map((t) => ({
+            id: t.technologyId,
+            version: t.version || undefined,
+            port: t.port,
+        })),
+    };
+    const url = generateShareUrl(shareable, opts.baseUrl);
+    const content = [
+        "",
+        `  ${chalk.cyan(url)}`,
+        "",
+        `  Share this URL ${chalk.dim("\u2014")} the recipient can`,
+        `  import it with:`,
+        `  ${chalk.white("stackweld import-url <url>")}`,
+        "",
+        `  No server needed ${chalk.dim("\u2014")} stack data is`,
+        `  encoded in the URL itself.`,
+        "",
+    ].join("\n");
+    console.log("");
+    console.log(box(content, `Stack Shared: ${stack.name}`));
+    console.log("");
+});
+export const importUrlCommand = new Command("import-url")
+    .description("Import a stack from a share URL")
+    .argument("<url>", "Share URL generated by stackweld share")
+    .option("--json", "Output result as JSON")
+    .action((url, opts) => {
+    let encoded;
+    try {
+        encoded = extractFromShareUrl(url);
+    }
+    catch {
+        console.error(chalk.red("Invalid share URL. Expected format: https://stackweld.dev/s/#<data>"));
+        process.exit(1);
+    }
+    let shareable;
+    try {
+        shareable = deserializeStack(encoded);
+    }
+    catch {
+        console.error(chalk.red("Failed to decode stack from URL. The data may be corrupted."));
+        process.exit(1);
+    }
+    const engine = getStackEngine();
+    const technologies = shareable.technologies.map((t) => ({
+        technologyId: t.id,
+        version: t.version || "latest",
+        port: t.port,
+    }));
+    const { stack, validation } = engine.create({
+        name: shareable.name,
+        profile: shareable.profile || "standard",
+        technologies,
+    });
+    console.log(formatValidation(validation));
+    console.log("");
+    if (opts.json) {
+        console.log(JSON.stringify({ stack, validation }, null, 2));
+    }
+    else {
+        console.log(formatStackRow(stack));
+        console.log("");
+        console.log(info(`Imported "${stack.name}" from shared URL`));
+        console.log("");
+    }
+});
+//# sourceMappingURL=share.js.map

package/dist/commands/status.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld status — Show status of Docker services.
+ */
+import { Command } from "commander";
+export declare const statusCommand: Command;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/status.js

@@ -0,0 +1,39 @@
+/**
+ * stackweld status — Show status of Docker services.
+ */
+import * as path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRuntimeManager } from "../ui/context.js";
+import { emptyState, error, formatJson, formatServiceStatus } from "../ui/format.js";
+export const statusCommand = new Command("status")
+    .description("Show status of running services")
+    .option("-p, --path <dir>", "Project directory", ".")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const runtime = getRuntimeManager();
+    const projectDir = path.resolve(opts.path);
+    if (!runtime.isDockerAvailable()) {
+        console.error(error("Docker is not available."));
+        console.error(chalk.dim("  Install Docker: https://docs.docker.com/get-docker/"));
+        process.exit(1);
+    }
+    const composePath = runtime.composeExists(projectDir);
+    if (!composePath) {
+        console.error(error(`No docker-compose.yml found in ${projectDir}`));
+        process.exit(1);
+    }
+    const services = runtime.status({ composePath, projectDir });
+    if (opts.json) {
+        console.log(formatJson(services));
+        return;
+    }
+    if (services.length === 0) {
+        console.log(emptyState("No services running.", "Run `stackweld up` to start services."));
+        return;
+    }
+    console.log(chalk.bold(`\n  Services (${services.length})\n`));
+    console.log(formatServiceStatus(services));
+    console.log("");
+});
+//# sourceMappingURL=status.js.map

package/dist/commands/template.d.ts

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

package/dist/commands/template.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import { input } from "@inquirer/prompts";
+import { getDatabase } from "@stackweld/core";
+import { getAllTemplates, getTemplate } from "@stackweld/templates";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { formatJson, formatStackRow, formatTemplate, formatValidation } from "../ui/format.js";
+export const templateCommand = new Command("template")
+    .description("Manage templates")
+    .addCommand(new Command("list")
+    .description("List all available templates")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const templates = getAllTemplates();
+    if (opts.json) {
+        console.log(formatJson(templates));
+        return;
+    }
+    console.log(chalk.bold(`${templates.length} template(s):\n`));
+    for (const t of templates) {
+        console.log(formatTemplate(t));
+        console.log("");
+    }
+}))
+    .addCommand(new Command("use")
+    .description("Create a stack from a template")
+    .argument("<template-id>", "Template ID")
+    .option("--name <name>", "Stack name")
+    .option("--json", "Output as JSON")
+    .action(async (templateId, opts) => {
+    const template = getTemplate(templateId);
+    if (!template) {
+        console.error(chalk.red(`Template "${templateId}" not found.`));
+        console.log(chalk.dim("Available: " +
+            getAllTemplates()
+                .map((t) => t.id)
+                .join(", ")));
+        process.exit(1);
+    }
+    const rules = getRulesEngine();
+    const engine = getStackEngine();
+    const name = opts.name ||
+        (await input({
+            message: "Stack name:",
+            default: template.variables.projectName || template.name,
+        }));
+    const technologies = template.technologyIds.map((tid) => {
+        const tech = rules.getTechnology(tid);
+        return { technologyId: tid, version: tech?.defaultVersion || "latest" };
+    });
+    const { stack, validation } = engine.create({
+        name,
+        description: template.description,
+        profile: template.profile,
+        technologies,
+        tags: [`template:${template.id}`],
+    });
+    console.log(formatValidation(validation));
+    console.log("");
+    if (opts.json) {
+        console.log(JSON.stringify({ stack, validation }, null, 2));
+    }
+    else {
+        console.log(formatStackRow(stack));
+        if (validation.valid) {
+            console.log(chalk.green(`\n✓ Created from template "${template.name}"`));
+        }
+    }
+}))
+    .addCommand(new Command("save")
+    .description("Save a stack as a reusable custom template")
+    .argument("<stack-id>", "Stack ID to save as template")
+    .option("--name <name>", "Template name")
+    .action(async (stackId, opts) => {
+    const engine = getStackEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${stackId}" not found.`));
+        process.exit(1);
+    }
+    const name = opts.name ||
+        (await input({
+            message: "Template name:",
+            default: `${stack.name} Template`,
+        }));
+    const db = getDatabase();
+    const id = randomUUID();
+    const techIds = stack.technologies.map((t) => t.technologyId);
+    db.prepare("INSERT INTO custom_templates (id, name, description, profile, technology_ids) VALUES (?, ?, ?, ?, ?)").run(id, name, stack.description, stack.profile, JSON.stringify(techIds));
+    console.log(chalk.green(`\n✓ Template "${name}" saved`));
+    console.log(chalk.dim(`  ID: ${id}`));
+    console.log(chalk.dim(`  Technologies: ${techIds.join(", ")}`));
+    console.log(chalk.dim(`  Profile: ${stack.profile}`));
+    console.log(chalk.dim(`\nUse it: stackweld template use-custom ${id}`));
+}))
+    .addCommand(new Command("saved")
+    .description("List saved custom templates")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const db = getDatabase();
+    const rows = db
+        .prepare("SELECT * FROM custom_templates ORDER BY created_at DESC")
+        .all();
+    if (rows.length === 0) {
+        console.log(chalk.dim("No custom templates saved yet. Use `stackweld template save <stack-id>`."));
+        return;
+    }
+    if (opts.json) {
+        console.log(formatJson(rows.map((r) => ({ ...r, technology_ids: JSON.parse(r.technology_ids) }))));
+        return;
+    }
+    console.log(chalk.bold(`${rows.length} custom template(s):\n`));
+    for (const row of rows) {
+        const techIds = JSON.parse(row.technology_ids);
+        console.log(`${chalk.bold.magenta(row.name)} ${chalk.dim(`(${row.id})`)}`);
+        console.log(`  ${chalk.dim("Profile:")} ${row.profile}`);
+        console.log(`  ${chalk.dim("Technologies:")} ${techIds.join(", ")}`);
+        console.log(`  ${chalk.dim("Created:")} ${row.created_at}`);
+        console.log("");
+    }
+}))
+    .addCommand(new Command("use-custom")
+    .description("Create a stack from a saved custom template")
+    .argument("<template-id>", "Custom template ID")
+    .option("--name <name>", "Stack name")
+    .action(async (templateId, opts) => {
+    const db = getDatabase();
+    const row = db
+        .prepare("SELECT * FROM custom_templates WHERE id = ?")
+        .get(templateId);
+    if (!row) {
+        console.error(chalk.red(`Custom template "${templateId}" not found.`));
+        process.exit(1);
+    }
+    const rules = getRulesEngine();
+    const engine = getStackEngine();
+    const techIds = JSON.parse(row.technology_ids);
+    const name = opts.name ||
+        (await input({
+            message: "Stack name:",
+            default: row.name.replace(" Template", ""),
+        }));
+    const technologies = techIds.map((tid) => {
+        const tech = rules.getTechnology(tid);
+        return { technologyId: tid, version: tech?.defaultVersion || "latest" };
+    });
+    const { stack, validation } = engine.create({
+        name,
+        description: row.description,
+        profile: row.profile,
+        technologies,
+        tags: [`custom-template:${row.name}`],
+    });
+    console.log(formatValidation(validation));
+    console.log("");
+    console.log(formatStackRow(stack));
+    if (validation.valid) {
+        console.log(chalk.green(`\n✓ Created from custom template "${row.name}"`));
+    }
+}));
+//# sourceMappingURL=template.js.map

package/dist/commands/up.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld up — Start Docker services for the current project.
+ */
+import { Command } from "commander";
+export declare const upCommand: Command;
+//# sourceMappingURL=up.d.ts.map

package/dist/commands/up.js

@@ -0,0 +1,54 @@
+/**
+ * stackweld up — Start Docker services for the current project.
+ */
+import * as path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { getRuntimeManager } from "../ui/context.js";
+import { error, formatServiceStatus } from "../ui/format.js";
+export const upCommand = new Command("up")
+    .description("Start Docker services")
+    .option("-p, --path <dir>", "Project directory", ".")
+    .option("--no-wait", "Don't wait for health checks")
+    .option("--timeout <ms>", "Health check timeout in ms", "60000")
+    .action(async (opts) => {
+    const runtime = getRuntimeManager();
+    const projectDir = path.resolve(opts.path);
+    if (!runtime.isDockerAvailable()) {
+        console.error(error("Docker is not available."));
+        console.error(chalk.dim("  Install Docker: https://docs.docker.com/get-docker/"));
+        console.error(chalk.dim("  Run `stackweld doctor` to check your environment."));
+        process.exit(1);
+    }
+    const composePath = runtime.composeExists(projectDir);
+    if (!composePath) {
+        console.error(error(`No docker-compose.yml found in ${projectDir}`));
+        console.error(chalk.dim("  Run `stackweld scaffold` to generate one from a stack."));
+        process.exit(1);
+    }
+    const runtimeOpts = { composePath, projectDir };
+    const spinner = ora("Starting services...").start();
+    const result = runtime.up(runtimeOpts);
+    if (!result.success) {
+        spinner.fail("Failed to start services");
+        console.error(chalk.red(result.output.slice(0, 500)));
+        process.exit(1);
+    }
+    spinner.succeed("Services started");
+    if (opts.wait !== false) {
+        const waitSpinner = ora("Waiting for health checks...").start();
+        const timeout = Number.parseInt(opts.timeout, 10) || 60_000;
+        const health = await runtime.waitForHealthy(runtimeOpts, timeout);
+        if (health.healthy) {
+            waitSpinner.succeed("All services healthy");
+        }
+        else {
+            waitSpinner.warn("Some services may not be healthy yet");
+        }
+        console.log("");
+        console.log(formatServiceStatus(health.services));
+        console.log("");
+    }
+});
+//# sourceMappingURL=up.js.map

package/dist/commands/version-cmd.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld version — Stack version management.
+ */
+import { Command } from "commander";
+export declare const versionCommand: Command;
+//# sourceMappingURL=version-cmd.d.ts.map

package/dist/commands/version-cmd.js

@@ -0,0 +1,100 @@
+/**
+ * stackweld version — Stack version management.
+ */
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { formatJson } from "../ui/format.js";
+export const versionCommand = new Command("version")
+    .description("Manage stack versions")
+    .addCommand(new Command("list")
+    .description("Show version history for a stack")
+    .argument("<stack-id>", "Stack ID")
+    .option("--json", "Output as JSON")
+    .action((stackId, opts) => {
+    const engine = getStackEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${stackId}" not found.`));
+        process.exit(1);
+    }
+    const history = engine.getVersionHistory(stackId);
+    if (opts.json) {
+        console.log(formatJson(history));
+        return;
+    }
+    console.log(chalk.bold(`Version history for "${stack.name}":\n`));
+    for (const v of history) {
+        console.log(`  ${chalk.cyan(`v${v.version}`)} ${chalk.dim(v.timestamp)} — ${v.changelog}`);
+    }
+}))
+    .addCommand(new Command("rollback")
+    .description("Rollback a stack to a previous version")
+    .argument("<stack-id>", "Stack ID")
+    .requiredOption("--to <version>", "Target version number")
+    .action((stackId, opts) => {
+    const engine = getStackEngine();
+    const targetVersion = Number.parseInt(opts.to, 10);
+    if (Number.isNaN(targetVersion)) {
+        console.error(chalk.red("Invalid version number."));
+        process.exit(1);
+    }
+    const result = engine.rollback(stackId, targetVersion);
+    if (!result) {
+        console.error(chalk.red(`Could not rollback to version ${targetVersion}.`));
+        process.exit(1);
+    }
+    console.log(chalk.green(`✓ Rolled back to v${targetVersion}`));
+}))
+    .addCommand(new Command("diff")
+    .description("Compare two versions of a stack")
+    .argument("<stack-id>", "Stack ID")
+    .argument("<version-a>", "First version")
+    .argument("<version-b>", "Second version")
+    .action((stackId, vA, vB) => {
+    const engine = getStackEngine();
+    const history = engine.getVersionHistory(stackId);
+    const a = Number.parseInt(vA, 10);
+    const b = Number.parseInt(vB, 10);
+    const snapshotA = history.find((h) => h.version === a);
+    const snapshotB = history.find((h) => h.version === b);
+    if (!snapshotA || !snapshotB) {
+        console.error(chalk.red("One or both versions not found."));
+        process.exit(1);
+    }
+    const techsA = new Set(snapshotA.snapshot.technologies.map((t) => t.technologyId));
+    const techsB = new Set(snapshotB.snapshot.technologies.map((t) => t.technologyId));
+    const added = [...techsB].filter((t) => !techsA.has(t));
+    const removed = [...techsA].filter((t) => !techsB.has(t));
+    const common = [...techsA].filter((t) => techsB.has(t));
+    console.log(chalk.bold(`Diff: v${a} → v${b}\n`));
+    if (added.length > 0) {
+        console.log(chalk.green("  Added:"));
+        for (const t of added)
+            console.log(chalk.green(`    + ${t}`));
+    }
+    if (removed.length > 0) {
+        console.log(chalk.red("  Removed:"));
+        for (const t of removed)
+            console.log(chalk.red(`    - ${t}`));
+    }
+    // Check version changes
+    for (const tid of common) {
+        const versionA = snapshotA.snapshot.technologies.find((t) => t.technologyId === tid)?.version;
+        const versionB = snapshotB.snapshot.technologies.find((t) => t.technologyId === tid)?.version;
+        if (versionA !== versionB) {
+            console.log(chalk.yellow(`  Changed: ${tid} ${versionA} → ${versionB}`));
+        }
+    }
+    if (added.length === 0 && removed.length === 0) {
+        console.log(chalk.dim("  No technology changes between versions."));
+    }
+    // Profile/name changes
+    if (snapshotA.snapshot.profile !== snapshotB.snapshot.profile) {
+        console.log(chalk.yellow(`  Profile: ${snapshotA.snapshot.profile} → ${snapshotB.snapshot.profile}`));
+    }
+    if (snapshotA.snapshot.name !== snapshotB.snapshot.name) {
+        console.log(chalk.yellow(`  Name: ${snapshotA.snapshot.name} → ${snapshotB.snapshot.name}`));
+    }
+}));
+//# sourceMappingURL=version-cmd.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Stackweld CLI — The operating system for your dev stacks.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Stackweld CLI — The operating system for your dev stacks.
+ */
+import chalk from "chalk";
+import { Command } from "commander";
+import { aiCommand } from "./commands/ai.js";
+import { analyzeCommand } from "./commands/analyze.js";
+import { benchmarkCommand } from "./commands/benchmark.js";
+import { browseCommand } from "./commands/browse.js";
+import { cloneCommand } from "./commands/clone.js";
+import { compareCommand } from "./commands/compare.js";
+import { completionCommand } from "./commands/completion.js";
+import { configCommand } from "./commands/config.js";
+import { costCommand } from "./commands/cost.js";
+import { createCommand } from "./commands/create.js";
+import { deleteCommand } from "./commands/delete.js";
+import { deployCommand } from "./commands/deploy.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { downCommand } from "./commands/down.js";
+import { envCommand } from "./commands/env.js";
+import { exportCommand } from "./commands/export-stack.js";
+import { generateCommand } from "./commands/generate.js";
+import { healthCommand } from "./commands/health.js";
+import { importCommand } from "./commands/import-stack.js";
+import { infoCommand } from "./commands/info.js";
+import { initCommand } from "./commands/init.js";
+import { learnCommand } from "./commands/learn.js";
+import { lintCommand } from "./commands/lint.js";
+import { listCommand } from "./commands/list.js";
+import { logsCommand } from "./commands/logs.js";
+import { migrateCommand } from "./commands/migrate.js";
+import { pluginCommand } from "./commands/plugin.js";
+import { previewCommand } from "./commands/preview.js";
+import { saveCommand } from "./commands/save.js";
+import { scaffoldCommand } from "./commands/scaffold.js";
+import { scoreCommand } from "./commands/score.js";
+import { importUrlCommand, shareCommand } from "./commands/share.js";
+import { statusCommand } from "./commands/status.js";
+import { templateCommand } from "./commands/template.js";
+import { upCommand } from "./commands/up.js";
+import { versionCommand } from "./commands/version-cmd.js";
+import { banner } from "./ui/format.js";
+// Read version from package.json at build time; fallback for development
+const VERSION = "0.2.0";
+const program = new Command();
+program
+    .name("stackweld")
+    .description("The operating system for your dev stacks")
+    .version(VERSION, "-V, --version", "Show version number")
+    .addCommand(initCommand)
+    .addCommand(createCommand)
+    .addCommand(generateCommand)
+    .addCommand(listCommand)
+    .addCommand(infoCommand)
+    .addCommand(browseCommand)
+    .addCommand(doctorCommand)
+    .addCommand(upCommand)
+    .addCommand(downCommand)
+    .addCommand(statusCommand)
+    .addCommand(logsCommand)
+    .addCommand(scaffoldCommand)
+    .addCommand(saveCommand)
+    .addCommand(deleteCommand)
+    .addCommand(cloneCommand)
+    .addCommand(exportCommand)
+    .addCommand(importCommand)
+    .addCommand(templateCommand)
+    .addCommand(configCommand)
+    .addCommand(completionCommand)
+    .addCommand(aiCommand)
+    .addCommand(scoreCommand)
+    .addCommand(analyzeCommand)
+    .addCommand(envCommand)
+    .addCommand(previewCommand)
+    .addCommand(shareCommand)
+    .addCommand(importUrlCommand)
+    .addCommand(healthCommand)
+    .addCommand(compareCommand)
+    .addCommand(migrateCommand)
+    .addCommand(learnCommand)
+    .addCommand(deployCommand)
+    .addCommand(lintCommand)
+    .addCommand(benchmarkCommand)
+    .addCommand(costCommand)
+    .addCommand(pluginCommand)
+    .addCommand(versionCommand);
+// Show banner when run without arguments
+if (process.argv.length <= 2) {
+    console.log(banner(VERSION));
+    console.log(chalk.bold("  Commands:"));
+    console.log("");
+    console.log(chalk.cyan("    Setup"));
+    console.log(`${chalk.dim("      init            ")}Create a new stack interactively`);
+    console.log(`${chalk.dim("      generate        ")}Scaffold a full project (one-shot)`);
+    console.log(`${chalk.dim("      create          ")}Scaffold from a stack or template`);
+    console.log(`${chalk.dim("      doctor          ")}Check system requirements`);
+    console.log("");
+    console.log(chalk.cyan("    Stacks"));
+    console.log(`${chalk.dim("      list            ")}List all saved stacks`);
+    console.log(`${chalk.dim("      info <id>       ")}Show stack or technology details`);
+    console.log(`${chalk.dim("      browse          ")}Browse technology catalog`);
+    console.log(`${chalk.dim("      save            ")}Save a version snapshot`);
+    console.log(`${chalk.dim("      delete          ")}Delete a saved stack`);
+    console.log(`${chalk.dim("      clone           ")}Duplicate a stack`);
+    console.log(`${chalk.dim("      export/import   ")}Export or import stack definitions`);
+    console.log(`${chalk.dim("      share <id>      ")}Generate a shareable URL for a stack`);
+    console.log(`${chalk.dim("      import-url <url> ")}Import a stack from a share URL`);
+    console.log(`${chalk.dim("      preview <id>    ")}Preview docker-compose.yml for a stack`);
+    console.log("");
+    console.log(chalk.cyan("    Runtime"));
+    console.log(`${chalk.dim("      up              ")}Start Docker services`);
+    console.log(`${chalk.dim("      down            ")}Stop Docker services`);
+    console.log(`${chalk.dim("      status          ")}Show service status`);
+    console.log(`${chalk.dim("      logs            ")}Show service logs`);
+    console.log("");
+    console.log(chalk.cyan("    Analysis"));
+    console.log(`${chalk.dim("      analyze [path]  ")}Detect project stack automatically`);
+    console.log(`${chalk.dim("      health [path]   ")}Check project health and best practices`);
+    console.log(`${chalk.dim("      compare <a> <b> ")}Compare two saved stacks`);
+    console.log(`${chalk.dim("      env [sync|check]")} Sync .env files and check for issues`);
+    console.log(`${chalk.dim("      score <a> [b]   ")}Compatibility score between technologies`);
+    console.log("");
+    console.log(chalk.cyan("    Deploy & Standards"));
+    console.log(`${chalk.dim("      deploy <id>     ")}Generate infrastructure files (VPS/AWS/GCP)`);
+    console.log(`${chalk.dim("      lint            ")}Validate stack against team standards`);
+    console.log(`${chalk.dim("      benchmark <id>  ")}Show performance profile for a stack`);
+    console.log(`${chalk.dim("      cost <id>       ")}Estimate monthly hosting costs`);
+    console.log("");
+    console.log(chalk.cyan("    Plugins"));
+    console.log(`${chalk.dim("      plugin list     ")}List installed plugins`);
+    console.log(`${chalk.dim("      plugin install  ")}Install a plugin from local directory`);
+    console.log(`${chalk.dim("      plugin remove   ")}Remove an installed plugin`);
+    console.log(`${chalk.dim("      plugin info     ")}Show plugin details`);
+    console.log("");
+    console.log(chalk.cyan("    Migration & Learning"));
+    console.log(`${chalk.dim("      migrate         ")}Generate a migration plan between techs`);
+    console.log(`${chalk.dim("      learn <tech>    ")}Show learning resources for a technology`);
+    console.log("");
+    console.log(chalk.cyan("    Extras"));
+    console.log(`${chalk.dim("      ai suggest      ")}AI-powered stack suggestions`);
+    console.log(`${chalk.dim("      template        ")}Manage templates`);
+    console.log(`${chalk.dim("      config          ")}Manage preferences`);
+    console.log(`${chalk.dim("      completion      ")}Generate shell completions`);
+    console.log("");
+    console.log(chalk.dim(`  Run ${chalk.white("stackweld <command> --help")} for detailed usage.`));
+    console.log("");
+    process.exit(0);
+}
+program.parseAsync(process.argv).catch((err) => {
+    if (err && err.code === "commander.unknownCommand") {
+        const cmd = process.argv[2];
+        console.error(chalk.red(`\u2716 Unknown command: "${cmd}"`));
+        console.error(chalk.dim(`  Run ${chalk.white("stackweld --help")} to see available commands.`));
+        process.exit(1);
+    }
+    console.error(chalk.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/ui/context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared CLI context — initializes engine instances once.
+ * All initialization is lazy with proper error handling.
+ */
+import { RulesEngine, RuntimeManager, ScaffoldOrchestrator, StackEngine } from "@stackweld/core";
+export declare function getRulesEngine(): RulesEngine;
+export declare function getStackEngine(): StackEngine;
+export declare function getScaffoldOrchestrator(): ScaffoldOrchestrator;
+export declare function getRuntimeManager(): RuntimeManager;
+//# sourceMappingURL=context.d.ts.map