@stackweld/cli 0.2.0

package/dist/commands/logs.js

@@ -0,0 +1,37 @@
+/**
+ * stackweld logs [service] — Show logs from Docker services.
+ */
+import * as path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRuntimeManager } from "../ui/context.js";
+import { error } from "../ui/format.js";
+export const logsCommand = new Command("logs")
+    .description("Show logs from Docker services")
+    .argument("[service]", "Service name (optional, shows all if omitted)")
+    .option("-p, --path <dir>", "Project directory", ".")
+    .option("-n, --tail <lines>", "Number of lines to show", "50")
+    .option("-f, --follow", "Follow log output")
+    .action((service, 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}`));
+        console.error(chalk.dim("  Run `stackweld scaffold` to generate one from a stack."));
+        process.exit(1);
+    }
+    const tail = Number.parseInt(opts.tail, 10) || 50;
+    const output = runtime.logs({ composePath, projectDir }, service, tail, opts.follow);
+    if (!output || output.trim().length === 0) {
+        console.log(chalk.dim(service ? `No logs for service "${service}".` : "No logs available."));
+        return;
+    }
+    console.log(output);
+});
+//# sourceMappingURL=logs.js.map

package/dist/commands/migrate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld migrate --from <techId> --to <techId> — Generate a migration plan between technologies.
+ */
+import { Command } from "commander";
+export declare const migrateCommand: Command;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/commands/migrate.js

@@ -0,0 +1,57 @@
+/**
+ * stackweld migrate --from <techId> --to <techId> — Generate a migration plan between technologies.
+ */
+import { planMigration } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine } from "../ui/context.js";
+import { box } from "../ui/format.js";
+const DIFFICULTY_COLORS = {
+    easy: chalk.green,
+    moderate: chalk.yellow,
+    hard: chalk.red,
+    expert: chalk.magenta,
+};
+export const migrateCommand = new Command("migrate")
+    .description("Generate a migration plan between two technologies")
+    .requiredOption("--from <techId>", "Source technology ID")
+    .requiredOption("--to <techId>", "Target technology ID")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const rules = getRulesEngine();
+    const techs = rules.getAllTechnologies();
+    const fromId = opts.from;
+    const toId = opts.to;
+    if (fromId === toId) {
+        console.error(chalk.red("\u2716 Source and target technologies must be different."));
+        process.exit(1);
+    }
+    const plan = planMigration(fromId, toId, techs);
+    if (opts.json) {
+        console.log(JSON.stringify(plan, null, 2));
+        return;
+    }
+    const diffColor = DIFFICULTY_COLORS[plan.difficulty] ?? chalk.white;
+    const lines = [];
+    lines.push("");
+    for (const step of plan.steps) {
+        lines.push(chalk.bold(`  Step ${step.order}: ${step.title}`));
+        lines.push(`  ${chalk.dim(step.description)}`);
+        if (step.commands && step.commands.length > 0) {
+            for (const cmd of step.commands) {
+                lines.push(`  ${chalk.cyan(cmd)}`);
+            }
+        }
+        if (step.files && step.files.length > 0) {
+            lines.push(`  ${chalk.dim("Files:")} ${step.files.join(", ")}`);
+        }
+        lines.push("");
+    }
+    const title = `Migration Plan: ${plan.from.name} \u2192 ${plan.to.name}`;
+    const subtitle = `Difficulty: ${diffColor(plan.difficulty.charAt(0).toUpperCase() + plan.difficulty.slice(1))} ${chalk.dim("\u00B7")} Est: ${plan.estimatedTime}`;
+    // Build a custom header with title + subtitle
+    const header = `${title}\n  ${subtitle}`;
+    console.log(box(lines.join("\n"), header));
+    console.log("");
+});
+//# sourceMappingURL=migrate.js.map

package/dist/commands/plugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * stackweld plugin — Manage Stackweld plugins.
+ *
+ * Subcommands: list, install, remove, info.
+ */
+import { Command } from "commander";
+export declare const pluginCommand: Command;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/commands/plugin.js

@@ -0,0 +1,131 @@
+/**
+ * stackweld plugin — Manage Stackweld plugins.
+ *
+ * Subcommands: list, install, remove, info.
+ */
+import { getPluginDir, getPluginInfo, installPlugin, listPlugins, removePlugin, } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { box, emptyState, formatJson, gradientHeader, table } from "../ui/format.js";
+// ─── plugin list ──────────────────────────────────────
+const pluginListCommand = new Command("list")
+    .description("List installed plugins")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const plugins = listPlugins();
+    if (opts.json) {
+        console.log(formatJson(plugins));
+        return;
+    }
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Plugins")}\n`);
+    if (plugins.length === 0) {
+        console.log(emptyState("No plugins installed.", "Install one with: stackweld plugin install <path>"));
+        return;
+    }
+    const data = plugins.map((p) => ({
+        name: p.name,
+        version: p.version,
+        type: p.type,
+        description: p.description.length > 40 ? `${p.description.slice(0, 37)}...` : p.description,
+    }));
+    const tbl = table(data, [
+        { header: "Name", key: "name", color: (v) => chalk.cyan(v) },
+        { header: "Version", key: "version" },
+        { header: "Type", key: "type", color: (v) => chalk.yellow(v) },
+        { header: "Description", key: "description", color: (v) => chalk.dim(v) },
+    ]);
+    console.log(`  ${chalk.dim("Plugin directory:")} ${getPluginDir()}\n`);
+    console.log(tbl);
+    console.log(`\n  ${chalk.dim(`${plugins.length} plugin(s) installed.`)}\n`);
+});
+// ─── plugin install ───────────────────────────────────
+const pluginInstallCommand = new Command("install")
+    .description("Install a plugin from a local directory")
+    .argument("<path>", "Path to plugin directory")
+    .option("--json", "Output as JSON")
+    .action((pluginPath, opts) => {
+    try {
+        const manifest = installPlugin(pluginPath);
+        if (opts.json) {
+            console.log(formatJson({ installed: true, plugin: manifest }));
+            return;
+        }
+        console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Plugin Install")}\n`);
+        console.log(`  ${chalk.green("\u2714")} Plugin ${chalk.cyan.bold(manifest.name)} v${manifest.version} installed successfully.`);
+        console.log(`  ${chalk.dim("Type:")} ${manifest.type}`);
+        console.log(`  ${chalk.dim("Description:")} ${manifest.description}`);
+        console.log(`  ${chalk.dim("Location:")} ${getPluginDir()}/${manifest.name}`);
+        console.log("");
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(formatJson({ installed: false, error: err instanceof Error ? err.message : String(err) }));
+            process.exit(1);
+        }
+        console.error(chalk.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+});
+// ─── plugin remove ────────────────────────────────────
+const pluginRemoveCommand = new Command("remove")
+    .description("Remove an installed plugin")
+    .argument("<name>", "Plugin name")
+    .option("--json", "Output as JSON")
+    .action((name, opts) => {
+    try {
+        removePlugin(name);
+        if (opts.json) {
+            console.log(formatJson({ removed: true, name }));
+            return;
+        }
+        console.log(`\n  ${chalk.green("\u2714")} Plugin ${chalk.cyan.bold(name)} removed.\n`);
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(formatJson({ removed: false, error: err instanceof Error ? err.message : String(err) }));
+            process.exit(1);
+        }
+        console.error(chalk.red(`\u2716 ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+});
+// ─── plugin info ──────────────────────────────────────
+const pluginInfoCommand = new Command("info")
+    .description("Show details about an installed plugin")
+    .argument("<name>", "Plugin name")
+    .option("--json", "Output as JSON")
+    .action((name, opts) => {
+    const manifest = getPluginInfo(name);
+    if (!manifest) {
+        if (opts.json) {
+            console.log(formatJson({ found: false, name }));
+            process.exit(1);
+        }
+        console.error(chalk.red(`\u2716 Plugin "${name}" not found.`));
+        console.error(chalk.dim("  Run: stackweld plugin list"));
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(formatJson(manifest));
+        return;
+    }
+    const lines = [
+        `${chalk.dim("Name:")}        ${chalk.cyan.bold(manifest.name)}`,
+        `${chalk.dim("Version:")}     ${manifest.version}`,
+        `${chalk.dim("Type:")}        ${chalk.yellow(manifest.type)}`,
+        `${chalk.dim("Description:")} ${manifest.description}`,
+        `${chalk.dim("Entry:")}       ${manifest.main}`,
+        `${chalk.dim("Location:")}    ${getPluginDir()}/${manifest.name}`,
+    ].join("\n");
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Plugin Info")}\n`);
+    console.log(box(lines, `Plugin: ${manifest.name}`));
+    console.log("");
+});
+// ─── Main plugin command ──────────────────────────────
+export const pluginCommand = new Command("plugin")
+    .description("Manage Stackweld plugins")
+    .addCommand(pluginListCommand)
+    .addCommand(pluginInstallCommand)
+    .addCommand(pluginRemoveCommand)
+    .addCommand(pluginInfoCommand);
+//# sourceMappingURL=plugin.js.map

package/dist/commands/preview.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stackweld preview <stackId> — Show the docker-compose.yml that would be generated.
+ * Does not create any files on disk.
+ */
+import { Command } from "commander";
+export declare const previewCommand: Command;
+//# sourceMappingURL=preview.d.ts.map

package/dist/commands/preview.js

@@ -0,0 +1,100 @@
+/**
+ * stackweld preview <stackId> — Show the docker-compose.yml that would be generated.
+ * Does not create any files on disk.
+ */
+import { generateComposePreview } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { box, info, sectionHeader, warning } from "../ui/format.js";
+export const previewCommand = new Command("preview")
+    .description("Preview the docker-compose.yml for a saved stack")
+    .argument("<id>", "Stack ID")
+    .option("--raw", "Output raw YAML without formatting")
+    .action((id, opts) => {
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    const stack = engine.get(id);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${id}" not found.`));
+        process.exit(1);
+    }
+    // Resolve full technology objects with stack-level port overrides
+    const technologies = stack.technologies
+        .map((st) => {
+        const tech = rules.getTechnology(st.technologyId);
+        if (!tech)
+            return null;
+        return {
+            id: tech.id,
+            name: tech.name,
+            category: tech.category,
+            dockerImage: tech.dockerImage,
+            defaultPort: tech.defaultPort,
+            envVars: tech.envVars,
+            healthCheck: tech.healthCheck,
+            port: st.port,
+        };
+    })
+        .filter((t) => t != null);
+    const dockerTechs = technologies.filter((t) => t.dockerImage);
+    if (dockerTechs.length === 0) {
+        console.log(warning("No Docker services in this stack."));
+        console.log(chalk.dim("  This stack only contains runtimes/frameworks that run locally."));
+        process.exit(0);
+    }
+    const result = generateComposePreview(technologies, stack.name);
+    if (opts.raw) {
+        console.log(result.yaml);
+        return;
+    }
+    // Syntax-highlighted YAML in a box
+    const highlighted = highlightYaml(result.yaml);
+    console.log("");
+    console.log(box(highlighted, `docker-compose.yml  ${chalk.dim(stack.name)}`));
+    // Service summary
+    console.log(sectionHeader("Services:"));
+    for (const svc of result.services) {
+        const port = result.ports[svc];
+        const portStr = port ? chalk.dim(`:${port}`) : "";
+        console.log(`  ${chalk.green("\u25CF")} ${chalk.cyan(svc)}${portStr}`);
+    }
+    if (result.volumes.length > 0) {
+        console.log(sectionHeader("Volumes:"));
+        for (const vol of result.volumes) {
+            console.log(`  ${chalk.dim("\u25CB")} ${vol}`);
+        }
+    }
+    console.log("");
+    console.log(info("This is a preview. No files were created."));
+    console.log(chalk.dim(`  Use ${chalk.white(`stackweld scaffold ${id}`)} to generate project files.`));
+    console.log("");
+});
+/**
+ * Basic YAML syntax highlighting for terminal output.
+ */
+function highlightYaml(yaml) {
+    return yaml
+        .split("\n")
+        .map((line) => {
+        // Comments
+        if (line.trimStart().startsWith("#")) {
+            return chalk.dim(line);
+        }
+        // Key: value lines
+        const match = line.match(/^(\s*)([\w.-]+)(:)(.*)/);
+        if (match) {
+            const [, indent, key, colon, value] = match;
+            return `${indent}${chalk.cyan(key)}${chalk.dim(colon)}${chalk.yellow(value)}`;
+        }
+        // List items
+        const listMatch = line.match(/^(\s*)(- )(.*)/);
+        if (listMatch) {
+            const [, indent, dash, value] = listMatch;
+            return `${indent}${chalk.dim(dash)}${chalk.yellow(value)}`;
+        }
+        return line;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=preview.js.map

package/dist/commands/save.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld save — Save the current stack state (creates version snapshot).
+ */
+import { Command } from "commander";
+export declare const saveCommand: Command;
+//# sourceMappingURL=save.d.ts.map

package/dist/commands/save.js

@@ -0,0 +1,32 @@
+/**
+ * stackweld save — Save the current stack state (creates version snapshot).
+ */
+import { input } from "@inquirer/prompts";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+export const saveCommand = new Command("save")
+    .description("Save a version snapshot of a stack")
+    .argument("<stack-id>", "Stack ID")
+    .option("-m, --message <msg>", "Version changelog message")
+    .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 message = opts.message ||
+        (await input({
+            message: "Changelog message:",
+            default: `Snapshot v${stack.version}`,
+        }));
+    // Trigger an update with no changes to create a new version snapshot
+    const result = engine.update(stackId, {});
+    if (!result) {
+        console.error(chalk.red("Failed to save stack."));
+        process.exit(1);
+    }
+    console.log(chalk.green(`✓ Saved "${stack.name}" as v${result.stack.version}: ${message}`));
+});
+//# sourceMappingURL=save.js.map

package/dist/commands/scaffold.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stackweld scaffold <stack-id> — Generate project files from a saved stack.
+ * Generates docker-compose.yml, .env.example, README.md, .gitignore, devcontainer.json.
+ */
+import { Command } from "commander";
+export declare const scaffoldCommand: Command;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/commands/scaffold.js

@@ -0,0 +1,100 @@
+/**
+ * stackweld scaffold <stack-id> — Generate project files from a saved stack.
+ * Generates docker-compose.yml, .env.example, README.md, .gitignore, devcontainer.json.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getScaffoldOrchestrator, getStackEngine } from "../ui/context.js";
+export const scaffoldCommand = new Command("scaffold")
+    .description("Generate project files from a saved stack")
+    .argument("<stack-id>", "Stack ID")
+    .option("-p, --path <dir>", "Output directory", ".")
+    .option("--dry-run", "Show what would be generated without writing")
+    .option("--git", "Initialize Git repository with initial commit")
+    .option("--json", "Output generated files as JSON")
+    .action((stackId, opts) => {
+    const engine = getStackEngine();
+    const orchestrator = getScaffoldOrchestrator();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${stackId}" not found.`));
+        process.exit(1);
+    }
+    const output = orchestrator.generate(stack);
+    const targetDir = path.resolve(opts.path);
+    if (opts.json) {
+        console.log(JSON.stringify(output, null, 2));
+        return;
+    }
+    const files = [];
+    if (output.dockerCompose) {
+        files.push({ path: "docker-compose.yml", content: output.dockerCompose });
+    }
+    files.push({ path: ".env.example", content: output.envExample });
+    files.push({ path: "README.md", content: output.readme });
+    files.push({ path: ".gitignore", content: output.gitignore });
+    files.push({
+        path: ".devcontainer/devcontainer.json",
+        content: output.devcontainer,
+    });
+    files.push({ path: "scripts/dev.sh", content: output.devScript });
+    files.push({ path: "scripts/setup.sh", content: output.setupScript });
+    files.push({ path: "Makefile", content: output.makefile });
+    files.push({
+        path: ".vscode/settings.json",
+        content: output.vscodeSettings,
+    });
+    files.push({
+        path: ".github/workflows/ci.yml",
+        content: output.ciWorkflow,
+    });
+    // Create all required directories (including empty ones like src/, tests/)
+    for (const dir of output.directories) {
+        const dirPath = path.join(targetDir, dir);
+        if (opts.dryRun) {
+            console.log(chalk.dim(`[dry-run] ${dir}/`));
+        }
+        else if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    for (const file of files) {
+        const filePath = path.join(targetDir, file.path);
+        if (opts.dryRun) {
+            console.log(chalk.dim(`[dry-run] ${file.path}`));
+            continue;
+        }
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filePath, file.content, "utf-8");
+        // Make shell scripts executable
+        if (file.path.endsWith(".sh")) {
+            fs.chmodSync(filePath, 0o755);
+        }
+        console.log(chalk.green(`  ✓ ${file.path}`));
+    }
+    if (!opts.dryRun) {
+        console.log("");
+        console.log(chalk.green(`✓ Generated ${files.length} files for "${stack.name}"`));
+        // Git init
+        if (opts.git) {
+            const gitResult = orchestrator.initGit(targetDir, stack);
+            if (gitResult.success) {
+                console.log(chalk.green(`  ✓ ${gitResult.message}`));
+            }
+            else {
+                console.log(chalk.yellow(`  ⚠ Git: ${gitResult.message}`));
+            }
+        }
+        if (output.scaffoldCommands.length > 0) {
+            console.log(chalk.bold("\nOfficial scaffold commands available:"));
+            for (const cmd of output.scaffoldCommands) {
+                console.log(`  ${chalk.dim("→")} ${cmd.name}: ${chalk.cyan(cmd.command)}`);
+            }
+        }
+    }
+});
+//# sourceMappingURL=scaffold.js.map

package/dist/commands/score.d.ts

@@ -0,0 +1,9 @@
+/**
+ * stackweld score <techA> [techB] — Show compatibility score between technologies.
+ *
+ * Two techs: detailed compatibility report.
+ * One tech: top 5 best and top 3 worst pairings from the catalog.
+ */
+import { Command } from "commander";
+export declare const scoreCommand: Command;
+//# sourceMappingURL=score.d.ts.map

package/dist/commands/score.js

@@ -0,0 +1,111 @@
+/**
+ * stackweld score <techA> [techB] — Show compatibility score between technologies.
+ *
+ * Two techs: detailed compatibility report.
+ * One tech: top 5 best and top 3 worst pairings from the catalog.
+ */
+import { scoreCompatibility } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine } from "../ui/context.js";
+import { box } from "../ui/format.js";
+export const scoreCommand = new Command("score")
+    .description("Show compatibility score between technologies")
+    .argument("<techA>", "First technology ID")
+    .argument("[techB]", "Second technology ID (optional)")
+    .option("--json", "Output as JSON")
+    .action((techA, techB, opts) => {
+    const rules = getRulesEngine();
+    const a = rules.getTechnology(techA);
+    if (!a) {
+        console.error(chalk.red(`\u2716 Technology "${techA}" not found in the registry.`));
+        process.exit(1);
+    }
+    if (techB) {
+        // ── Two-tech mode: detailed compatibility ──
+        const b = rules.getTechnology(techB);
+        if (!b) {
+            console.error(chalk.red(`\u2716 Technology "${techB}" not found in the registry.`));
+            process.exit(1);
+        }
+        const result = scoreCompatibility(a, b);
+        if (opts.json) {
+            console.log(JSON.stringify({ techA: a.id, techB: b.id, ...result }, null, 2));
+            return;
+        }
+        const barWidth = 20;
+        const filled = Math.round((result.score / 100) * barWidth);
+        const empty = barWidth - filled;
+        const barColor = result.score >= 75 ? chalk.green : result.score >= 45 ? chalk.yellow : chalk.red;
+        const bar = barColor("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty));
+        const lines = [];
+        lines.push("");
+        lines.push(`        ${bar}  ${chalk.bold(String(result.score))}/100`);
+        lines.push(`             Grade: ${chalk.yellow.bold(result.grade)}`);
+        lines.push("");
+        if (result.factors.length > 0) {
+            lines.push("  Factors:");
+            for (const f of result.factors) {
+                const icon = f.points >= 0 ? chalk.green("\u2713") : chalk.red("\u2717");
+                const sign = f.points >= 0 ? "+" : "";
+                const pointStr = f.points >= 0 ? chalk.green(`${sign}${f.points}`) : chalk.red(`${f.points}`);
+                lines.push(`  ${icon} ${pointStr}  ${f.description}`);
+            }
+            lines.push("");
+        }
+        lines.push(`  ${chalk.dim(`"${result.recommendation}"`)}`);
+        lines.push("");
+        const title = `Compatibility Score: ${a.name} + ${b.name}`;
+        console.log(box(lines.join("\n"), title));
+    }
+    else {
+        // ── Single-tech mode: best & worst pairings ──
+        const allTechs = rules.getAllTechnologies().filter((t) => t.id !== a.id);
+        const scored = allTechs.map((t) => ({
+            tech: t,
+            result: scoreCompatibility(a, t),
+        }));
+        scored.sort((x, y) => y.result.score - x.result.score);
+        if (opts.json) {
+            const data = scored.map((s) => ({
+                id: s.tech.id,
+                name: s.tech.name,
+                score: s.result.score,
+                grade: s.result.grade,
+            }));
+            console.log(JSON.stringify({ technology: a.id, pairings: data }, null, 2));
+            return;
+        }
+        console.log("");
+        console.log(chalk.bold.cyan(`  ${a.name}`) + chalk.dim(` (${a.id})`));
+        console.log(chalk.dim(`  ${a.category} — ${a.description}`));
+        console.log("");
+        // Top 5 best
+        console.log(chalk.green.bold("  Top 5 Best Pairings:"));
+        console.log("");
+        const best = scored.slice(0, 5);
+        for (const item of best) {
+            const barWidth = 15;
+            const filled = Math.round((item.result.score / 100) * barWidth);
+            const empty = barWidth - filled;
+            const bar = chalk.green("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty));
+            console.log(`    ${bar} ${chalk.bold(String(item.result.score).padStart(3))}/100  ` +
+                `${chalk.yellow(item.result.grade)}  ${chalk.cyan(item.tech.name)} ${chalk.dim(`(${item.tech.category})`)}`);
+        }
+        console.log("");
+        // Top 3 worst
+        console.log(chalk.red.bold("  Top 3 Worst Pairings:"));
+        console.log("");
+        const worst = scored.slice(-3).reverse();
+        for (const item of worst) {
+            const barWidth = 15;
+            const filled = Math.round((item.result.score / 100) * barWidth);
+            const empty = barWidth - filled;
+            const bar = chalk.red("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty));
+            console.log(`    ${bar} ${chalk.bold(String(item.result.score).padStart(3))}/100  ` +
+                `${chalk.yellow(item.result.grade)}  ${chalk.cyan(item.tech.name)} ${chalk.dim(`(${item.tech.category})`)}`);
+        }
+        console.log("");
+    }
+});
+//# sourceMappingURL=score.js.map

package/dist/commands/share.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 { Command } from "commander";
+export declare const shareCommand: Command;
+export declare const importUrlCommand: Command;
+//# sourceMappingURL=share.d.ts.map