@stackweld/cli 0.2.0

package/dist/ui/context.js

@@ -0,0 +1,90 @@
+/**
+ * Shared CLI context — initializes engine instances once.
+ * All initialization is lazy with proper error handling.
+ */
+import { RulesEngine, RuntimeManager, ScaffoldOrchestrator, StackEngine } from "@stackweld/core";
+import { loadAllTechnologies } from "@stackweld/registry";
+import chalk from "chalk";
+let _techs = null;
+let _rulesEngine = null;
+let _stackEngine = null;
+let _scaffoldOrchestrator = null;
+let _runtimeManager = null;
+function getTechs() {
+    if (!_techs) {
+        try {
+            _techs = loadAllTechnologies();
+        }
+        catch (err) {
+            console.error(chalk.red("\u2716 Failed to load technology registry."));
+            if (err instanceof Error) {
+                console.error(chalk.dim(`  ${err.message}`));
+            }
+            console.error(chalk.dim("  Make sure @stackweld/registry is built: pnpm build"));
+            process.exit(1);
+        }
+    }
+    return _techs;
+}
+export function getRulesEngine() {
+    if (!_rulesEngine) {
+        try {
+            _rulesEngine = new RulesEngine(getTechs());
+        }
+        catch (err) {
+            console.error(chalk.red("\u2716 Failed to initialize rules engine."));
+            if (err instanceof Error)
+                console.error(chalk.dim(`  ${err.message}`));
+            process.exit(1);
+        }
+    }
+    return _rulesEngine;
+}
+export function getStackEngine() {
+    if (!_stackEngine) {
+        try {
+            _stackEngine = new StackEngine(getRulesEngine());
+        }
+        catch (err) {
+            console.error(chalk.red("\u2716 Failed to initialize stack engine."));
+            if (err instanceof Error) {
+                console.error(chalk.dim(`  ${err.message}`));
+            }
+            if (String(err).includes("SQLITE") || String(err).includes("database")) {
+                console.error(chalk.dim("  The local database could not be created or opened."));
+                console.error(chalk.dim("  Check write permissions in your home directory (~/.stackweld/)."));
+            }
+            process.exit(1);
+        }
+    }
+    return _stackEngine;
+}
+export function getScaffoldOrchestrator() {
+    if (!_scaffoldOrchestrator) {
+        try {
+            _scaffoldOrchestrator = new ScaffoldOrchestrator(getTechs());
+        }
+        catch (err) {
+            console.error(chalk.red("\u2716 Failed to initialize scaffold orchestrator."));
+            if (err instanceof Error)
+                console.error(chalk.dim(`  ${err.message}`));
+            process.exit(1);
+        }
+    }
+    return _scaffoldOrchestrator;
+}
+export function getRuntimeManager() {
+    if (!_runtimeManager) {
+        try {
+            _runtimeManager = new RuntimeManager(getTechs());
+        }
+        catch (err) {
+            console.error(chalk.red("\u2716 Failed to initialize runtime manager."));
+            if (err instanceof Error)
+                console.error(chalk.dim(`  ${err.message}`));
+            process.exit(1);
+        }
+    }
+    return _runtimeManager;
+}
+//# sourceMappingURL=context.js.map

package/dist/ui/format.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared formatting utilities for CLI output.
+ * Premium visual design for Stackweld CLI.
+ */
+import type { StackDefinition, Technology, Template, ValidationResult } from "@stackweld/core";
+declare const ICONS: {
+    readonly success: string;
+    readonly error: string;
+    readonly warning: string;
+    readonly info: string;
+    readonly bullet: string;
+    readonly arrow: string;
+    readonly dot: {
+        readonly green: string;
+        readonly red: string;
+        readonly yellow: string;
+        readonly blue: string;
+        readonly dim: string;
+    };
+};
+declare const BRAND_COLOR: import("chalk").ChalkInstance;
+export declare function success(message: string): string;
+export declare function error(message: string): string;
+export declare function warning(message: string): string;
+export declare function info(message: string): string;
+export declare function dim(message: string): string;
+export declare function label(key: string, value: string): string;
+export declare function banner(version: string): string;
+export declare function gradientHeader(text: string): string;
+export declare function sectionHeader(title: string): string;
+export declare function box(content: string, title?: string): string;
+interface TableColumn {
+    header: string;
+    key: string;
+    align?: "left" | "right";
+    color?: (v: string) => string;
+}
+export declare function table(data: Record<string, string>[], columns: TableColumn[]): string;
+export declare function progressBar(current: number, total: number, width?: number): string;
+export declare function stepIndicator(current: number, total: number, label: string): string;
+export declare function formatStackRow(stack: StackDefinition): string;
+export declare function formatStackTable(stacks: StackDefinition[]): string;
+export declare function formatStackSummary(stack: StackDefinition): string;
+export declare function formatTechnology(tech: Technology): string;
+export declare function formatTechTable(techs: Technology[]): string;
+export declare function formatTemplate(template: Template): string;
+export declare function formatValidation(result: ValidationResult): string;
+export declare function formatServiceStatus(services: Array<{
+    name: string;
+    status: string;
+    port?: number;
+    healthCheck?: string;
+}>): string;
+export declare function formatToolCheck(name: string, found: boolean, version?: string, suggestion?: string): string;
+export declare function formatJson(data: unknown): string;
+export declare function emptyState(message: string, hint?: string): string;
+export declare function nextSteps(steps: string[]): string;
+export { BRAND_COLOR, ICONS };
+//# sourceMappingURL=format.d.ts.map

package/dist/ui/format.js

@@ -0,0 +1,295 @@
+/**
+ * Shared formatting utilities for CLI output.
+ * Premium visual design for Stackweld CLI.
+ */
+import chalk from "chalk";
+// ─── Constants ─────────────────────────────────────────
+const ICONS = {
+    success: chalk.green("\u2714"),
+    error: chalk.red("\u2716"),
+    warning: chalk.yellow("\u26A0"),
+    info: chalk.blue("\u2139"),
+    bullet: chalk.dim("\u2022"),
+    arrow: chalk.dim("\u2192"),
+    dot: {
+        green: chalk.green("\u25CF"),
+        red: chalk.red("\u25CF"),
+        yellow: chalk.yellow("\u25CF"),
+        blue: chalk.blue("\u25CF"),
+        dim: chalk.dim("\u25CB"),
+    },
+};
+const BOX = {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2500",
+    v: "\u2502",
+};
+const BRAND_COLOR = chalk.hex("#7C5CFC");
+// ─── Message Functions ─────────────────────────────────
+export function success(message) {
+    return `${ICONS.success} ${chalk.green(message)}`;
+}
+export function error(message) {
+    return `${ICONS.error} ${chalk.red(message)}`;
+}
+export function warning(message) {
+    return `${ICONS.warning} ${chalk.yellow(message)}`;
+}
+export function info(message) {
+    return `${ICONS.info} ${chalk.blue(message)}`;
+}
+export function dim(message) {
+    return chalk.dim(message);
+}
+export function label(key, value) {
+    return `  ${chalk.dim(`${key}:`)} ${value}`;
+}
+// ─── Banner & Headers ──────────────────────────────────
+export function banner(version) {
+    const lines = [
+        "",
+        BRAND_COLOR.bold("  Stackweld") + chalk.dim(` v${version}`),
+        chalk.dim("  The operating system for your dev stacks"),
+        "",
+    ];
+    return lines.join("\n");
+}
+export function gradientHeader(text) {
+    const colors = ["#7C5CFC", "#6B8AFF", "#5CB8FF", "#4DE4FC"];
+    let result = "";
+    for (let i = 0; i < text.length; i++) {
+        const color = colors[Math.floor((i / text.length) * colors.length)];
+        result += chalk.hex(color).bold(text[i]);
+    }
+    return result;
+}
+export function sectionHeader(title) {
+    return `\n${chalk.bold(title)}`;
+}
+// ─── Box Drawing ───────────────────────────────────────
+export function box(content, title) {
+    const lines = content.split("\n");
+    const maxLen = Math.max(...lines.map((l) => stripAnsi(l).length), title ? stripAnsi(title).length + 2 : 0);
+    const width = Math.min(Math.max(maxLen + 4, 40), 80);
+    const innerWidth = width - 2;
+    const hLine = BOX.h.repeat(innerWidth);
+    const topLine = title
+        ? `${BOX.tl}${BOX.h} ${chalk.bold(title)} ${BOX.h.repeat(Math.max(0, innerWidth - stripAnsi(title).length - 3))}${BOX.tr}`
+        : `${BOX.tl}${hLine}${BOX.tr}`;
+    const paddedLines = lines.map((line) => {
+        const visLen = stripAnsi(line).length;
+        const padding = Math.max(0, innerWidth - visLen - 2);
+        return `${BOX.v} ${line}${" ".repeat(padding)} ${BOX.v}`;
+    });
+    return [topLine, ...paddedLines, `${BOX.bl}${hLine}${BOX.br}`].join("\n");
+}
+function stripAnsi(str) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences require matching the ESC control character
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+export function table(data, columns) {
+    if (data.length === 0)
+        return "";
+    // Compute column widths
+    const widths = columns.map((col) => {
+        const headerLen = col.header.length;
+        const maxDataLen = Math.max(0, ...data.map((row) => (row[col.key] || "").length));
+        return Math.max(headerLen, maxDataLen);
+    });
+    // Header
+    const headerLine = columns
+        .map((col, i) => chalk.bold(pad(col.header, widths[i], col.align)))
+        .join("  ");
+    const separator = columns.map((_, i) => chalk.dim("\u2500".repeat(widths[i]))).join("  ");
+    // Rows
+    const rows = data.map((row) => columns
+        .map((col, i) => {
+        const value = row[col.key] || "";
+        const padded = pad(value, widths[i], col.align);
+        return col.color ? col.color(padded) : padded;
+    })
+        .join("  "));
+    return [headerLine, separator, ...rows].join("\n");
+}
+function pad(str, len, align = "left") {
+    if (align === "right")
+        return str.padStart(len);
+    return str.padEnd(len);
+}
+// ─── Progress Indicator ────────────────────────────────
+export function progressBar(current, total, width = 30) {
+    const ratio = Math.min(current / total, 1);
+    const filled = Math.round(width * ratio);
+    const empty = width - filled;
+    const bar = chalk.green("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty));
+    const pct = Math.round(ratio * 100);
+    return `${bar} ${chalk.dim(`${pct}%`)}`;
+}
+export function stepIndicator(current, total, label) {
+    return `${chalk.dim(`[${current}/${total}]`)} ${label}`;
+}
+// ─── Stack Formatting ──────────────────────────────────
+export function formatStackRow(stack) {
+    const techs = stack.technologies.map((t) => t.technologyId).join(", ");
+    return `${chalk.cyan.bold(stack.name)} ${chalk.dim(`(${stack.profile})`)}  ${chalk.dim(`v${stack.version}`)}
+  ${chalk.dim("ID:")} ${stack.id}
+  ${chalk.dim("Technologies:")} ${techs}
+  ${chalk.dim("Updated:")} ${stack.updatedAt}`;
+}
+export function formatStackTable(stacks) {
+    const data = stacks.map((s) => ({
+        name: s.name,
+        profile: s.profile,
+        techs: s.technologies.map((t) => t.technologyId).join(", "),
+        version: `v${s.version}`,
+        updated: typeof s.updatedAt === "string" ? s.updatedAt.split("T")[0] : String(s.updatedAt),
+    }));
+    return table(data, [
+        { header: "Name", key: "name", color: (v) => chalk.cyan(v) },
+        { header: "Profile", key: "profile" },
+        { header: "Technologies", key: "techs", color: (v) => chalk.dim(v) },
+        { header: "Ver", key: "version" },
+        { header: "Updated", key: "updated", color: (v) => chalk.dim(v) },
+    ]);
+}
+export function formatStackSummary(stack) {
+    const techs = stack.technologies.map((t) => t.technologyId).join(", ");
+    const content = [
+        `${chalk.dim("Name:")}     ${chalk.cyan.bold(stack.name)}`,
+        `${chalk.dim("Profile:")}  ${stack.profile}`,
+        `${chalk.dim("Version:")}  v${stack.version}`,
+        `${chalk.dim("Techs:")}    ${techs}`,
+        `${chalk.dim("ID:")}       ${chalk.dim(stack.id)}`,
+    ].join("\n");
+    return box(content, "Stack Summary");
+}
+export function formatTechnology(tech) {
+    const lines = [
+        `${chalk.bold.cyan(tech.name)} ${chalk.dim(`(${tech.id})`)}`,
+        `  ${chalk.dim("Category:")} ${tech.category}`,
+        `  ${chalk.dim("Description:")} ${tech.description}`,
+        `  ${chalk.dim("Default version:")} ${tech.defaultVersion}`,
+    ];
+    if (tech.defaultPort) {
+        lines.push(`  ${chalk.dim("Default port:")} ${tech.defaultPort}`);
+    }
+    if (tech.requires.length > 0) {
+        lines.push(`  ${chalk.dim("Requires:")} ${tech.requires.join(", ")}`);
+    }
+    if (tech.incompatibleWith.length > 0) {
+        lines.push(`  ${chalk.dim("Incompatible with:")} ${tech.incompatibleWith.join(", ")}`);
+    }
+    if (tech.suggestedWith.length > 0) {
+        lines.push(`  ${chalk.dim("Suggested with:")} ${tech.suggestedWith.join(", ")}`);
+    }
+    if (tech.officialScaffold) {
+        lines.push(`  ${chalk.dim("Scaffold:")} ${tech.officialScaffold}`);
+    }
+    if (tech.dockerImage) {
+        lines.push(`  ${chalk.dim("Docker:")} ${tech.dockerImage}`);
+    }
+    return lines.join("\n");
+}
+export function formatTechTable(techs) {
+    const data = techs.map((t) => ({
+        name: t.name,
+        id: t.id,
+        category: t.category,
+        version: t.defaultVersion,
+        port: t.defaultPort ? String(t.defaultPort) : "-",
+    }));
+    return table(data, [
+        { header: "Name", key: "name", color: (v) => chalk.cyan(v) },
+        { header: "ID", key: "id", color: (v) => chalk.dim(v) },
+        { header: "Category", key: "category" },
+        { header: "Version", key: "version" },
+        { header: "Port", key: "port", align: "right" },
+    ]);
+}
+export function formatTemplate(template) {
+    return `${chalk.bold.magenta(template.name)} ${chalk.dim(`(${template.id})`)}
+  ${chalk.dim("Profile:")} ${template.profile}
+  ${chalk.dim("Description:")} ${template.description}
+  ${chalk.dim("Technologies:")} ${template.technologyIds.join(", ")}
+  ${chalk.dim("Scaffold steps:")} ${template.scaffoldSteps.length}
+  ${chalk.dim("Hooks:")} ${template.hooks.length}`;
+}
+export function formatValidation(result) {
+    const lines = [];
+    if (result.valid) {
+        lines.push(success("Stack is valid"));
+    }
+    else {
+        lines.push(error("Stack has errors"));
+    }
+    for (const issue of result.issues) {
+        const icon = issue.severity === "error"
+            ? ICONS.error
+            : issue.severity === "warning"
+                ? ICONS.warning
+                : ICONS.info;
+        lines.push(`  ${icon} ${issue.message}`);
+        if (issue.suggestedFix) {
+            lines.push(`    ${chalk.dim("Fix:")} ${issue.suggestedFix}`);
+        }
+    }
+    if (result.resolvedDependencies.length > 0) {
+        lines.push(`  ${chalk.dim("Auto-resolved:")} ${result.resolvedDependencies.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+// ─── Service Status ────────────────────────────────────
+export function formatServiceStatus(services) {
+    if (services.length === 0)
+        return chalk.dim("No services running.");
+    const lines = services.map((svc) => {
+        const icon = svc.status === "healthy" || svc.status === "running"
+            ? ICONS.dot.green
+            : svc.status === "exited"
+                ? ICONS.dot.red
+                : ICONS.dot.yellow;
+        const port = svc.port ? chalk.dim(`:${svc.port}`) : "";
+        const health = svc.healthCheck === "passing"
+            ? chalk.green(" healthy")
+            : svc.healthCheck === "failing"
+                ? chalk.red(" unhealthy")
+                : "";
+        return `  ${icon} ${chalk.cyan(svc.name)}${port} ${chalk.dim(svc.status)}${health}`;
+    });
+    return lines.join("\n");
+}
+// ─── Tool Check Status ─────────────────────────────────
+export function formatToolCheck(name, found, version, suggestion) {
+    const icon = found ? ICONS.success : ICONS.error;
+    const detail = found ? chalk.dim(version || "") : chalk.dim("not found");
+    let line = `  ${icon} ${name} ${detail}`;
+    if (!found && suggestion) {
+        line += `\n    ${ICONS.arrow} ${chalk.dim(suggestion)}`;
+    }
+    return line;
+}
+// ─── Utility ───────────────────────────────────────────
+export function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}
+export function emptyState(message, hint) {
+    const lines = [`\n  ${chalk.dim(message)}`];
+    if (hint) {
+        lines.push(`  ${ICONS.arrow} ${chalk.dim(hint)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function nextSteps(steps) {
+    const lines = [sectionHeader("Next steps:")];
+    for (const step of steps) {
+        lines.push(`  ${ICONS.arrow} ${chalk.dim(step)}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export { BRAND_COLOR, ICONS };
+//# sourceMappingURL=format.js.map

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@stackweld/cli",
+  "version": "0.2.0",
+  "description": "The operating system for your dev stacks — define, validate, scaffold, and launch development environments from the terminal.",
+  "license": "MIT",
+  "author": "Orlando Fernandez <hello@xplustechnologies.com>",
+  "homepage": "https://github.com/mundowise/Stackweld",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mundowise/Stackweld.git",
+    "directory": "packages/cli"
+  },
+  "keywords": ["cli", "devtools", "scaffold", "stack", "docker", "developer-tools", "project-generator"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "stackweld": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "clean": "rm -rf dist .turbo"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
+    "@inquirer/prompts": "^7.0.0",
+    "@stackweld/core": "workspace:*",
+    "@stackweld/registry": "workspace:*",
+    "@stackweld/templates": "workspace:*",
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "ora": "^8.0.0",
+    "yaml": "^2.8.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.2"
+  }
+}