@stackweld/cli 0.2.0

package/dist/commands/deploy.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld deploy <stackId> --target <vps|aws|gcp> — Generate infrastructure files.
+ */
+import { Command } from "commander";
+export declare const deployCommand: Command;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.js

@@ -0,0 +1,90 @@
+/**
+ * stackweld deploy <stackId> --target <vps|aws|gcp> — Generate infrastructure files.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { generateInfra } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { box, formatJson, gradientHeader, nextSteps } from "../ui/format.js";
+const VALID_TARGETS = new Set(["vps", "aws", "gcp"]);
+export const deployCommand = new Command("deploy")
+    .description("Generate infrastructure-as-code files for a saved stack")
+    .argument("<stack-id>", "Stack ID to generate infra for")
+    .requiredOption("-t, --target <target>", "Deploy target: vps, aws, or gcp")
+    .option("-o, --output <dir>", "Output directory", ".")
+    .option("--json", "Output as JSON")
+    .option("--dry-run", "Show what would be generated without writing files")
+    .action((stackId, opts) => {
+    const target = opts.target;
+    if (!VALID_TARGETS.has(target)) {
+        console.error(chalk.red(`\u2716 Invalid target "${opts.target}". Use: vps, aws, or gcp`));
+        process.exit(1);
+    }
+    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 for each stack technology
+    const technologies = stack.technologies.map((st) => {
+        const tech = rules.getTechnology(st.technologyId);
+        return {
+            id: st.technologyId,
+            name: tech?.name || st.technologyId,
+            category: tech?.category || "runtime",
+            dockerImage: tech?.dockerImage,
+            defaultPort: st.port || tech?.defaultPort,
+        };
+    });
+    const result = generateInfra(technologies, stack.name, target);
+    if (opts.json) {
+        console.log(formatJson(result));
+        return;
+    }
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Deploy")}\n`);
+    // Build content
+    const lines = [];
+    lines.push("");
+    lines.push(`  ${chalk.dim("Stack:")}    ${chalk.cyan.bold(stack.name)}`);
+    lines.push(`  ${chalk.dim("Target:")}   ${chalk.yellow(target.toUpperCase())}`);
+    lines.push(`  ${chalk.dim("Files:")}    ${result.files.length}`);
+    lines.push("");
+    for (const file of result.files) {
+        const sizeKB = (Buffer.byteLength(file.content, "utf-8") / 1024).toFixed(1);
+        lines.push(`  ${chalk.green("\u2713")} ${chalk.white(file.path)} ${chalk.dim(`(${sizeKB}KB)`)}`);
+    }
+    lines.push("");
+    console.log(box(lines.join("\n"), `Infrastructure: ${target.toUpperCase()}`));
+    // Write files unless dry-run
+    if (!opts.dryRun) {
+        const outputDir = path.resolve(opts.output);
+        let written = 0;
+        for (const file of result.files) {
+            const filePath = path.join(outputDir, file.path);
+            const dirName = path.dirname(filePath);
+            if (!fs.existsSync(dirName)) {
+                fs.mkdirSync(dirName, { recursive: true });
+            }
+            fs.writeFileSync(filePath, file.content, "utf-8");
+            // Make shell scripts executable
+            if (file.path.endsWith(".sh")) {
+                fs.chmodSync(filePath, 0o755);
+            }
+            written++;
+        }
+        console.log(chalk.green(`  \u2713 ${written} file(s) written to ${outputDir}`));
+    }
+    else {
+        console.log(chalk.yellow("  Dry run — no files written."));
+    }
+    // Show instructions
+    if (result.instructions.length > 0) {
+        console.log(nextSteps(result.instructions));
+    }
+});
+//# sourceMappingURL=deploy.js.map

package/dist/commands/doctor.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld doctor — Detect system capabilities and issues.
+ */
+import { Command } from "commander";
+export declare const doctorCommand: Command;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -0,0 +1,144 @@
+/**
+ * stackweld doctor — Detect system capabilities and issues.
+ */
+import { execSync } from "node:child_process";
+import * as os from "node:os";
+import chalk from "chalk";
+import { Command } from "commander";
+import { box, formatJson, formatToolCheck, gradientHeader, ICONS, sectionHeader, } from "../ui/format.js";
+const INSTALL_SUGGESTIONS = {
+    "Node.js": "https://nodejs.org  or  nvm install --lts",
+    npm: "Included with Node.js",
+    pnpm: "npm install -g pnpm",
+    Docker: "https://docs.docker.com/get-docker/",
+    "Docker Compose": "Included with Docker Desktop, or: apt install docker-compose-plugin",
+    Git: "apt install git  or  https://git-scm.com",
+    Python: "https://python.org  or  apt install python3",
+    Go: "https://go.dev/dl/  or  snap install go",
+    Rust: "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh",
+    Cargo: "Included with Rust (rustup)",
+    Bun: "curl -fsSL https://bun.sh/install | bash",
+};
+function check(name, command) {
+    try {
+        const output = execSync(command, { stdio: "pipe", timeout: 5000 }).toString().trim();
+        const versionMatch = output.match(/(\d+\.\d+[.\d]*)/);
+        return {
+            name,
+            status: "ok",
+            version: versionMatch?.[1] || output.slice(0, 50),
+        };
+    }
+    catch {
+        return { name, status: "not_found", message: `${name} not found` };
+    }
+}
+export const doctorCommand = new Command("doctor")
+    .description("Check system requirements and environment")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const results = [];
+    // System info
+    const sysInfo = {
+        platform: os.platform(),
+        arch: os.arch(),
+        release: os.release(),
+        cpus: os.cpus().length,
+        memory: `${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`,
+        freeMemory: `${Math.round(os.freemem() / 1024 / 1024 / 1024)}GB`,
+        hostname: os.hostname(),
+    };
+    // Check runtimes & tools (including all required ones)
+    results.push(check("Node.js", "node --version"));
+    results.push(check("npm", "npm --version"));
+    results.push(check("pnpm", "pnpm --version"));
+    results.push(check("Docker", "docker --version"));
+    results.push(check("Docker Compose", "docker compose version"));
+    results.push(check("Git", "git --version"));
+    results.push(check("Python", "python3 --version"));
+    results.push(check("Go", "go version"));
+    results.push(check("Rust", "rustc --version"));
+    results.push(check("Cargo", "cargo --version"));
+    results.push(check("Bun", "bun --version"));
+    // Check ports
+    const portChecks = [];
+    const commonPorts = [3000, 5432, 6379, 8000, 8080, 27017];
+    for (const port of commonPorts) {
+        try {
+            execSync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null || ss -tlnp 2>/dev/null | grep :${port}`, { stdio: "pipe", timeout: 2000 });
+            portChecks.push({
+                name: `Port ${port}`,
+                status: "warning",
+                message: `in use`,
+            });
+        }
+        catch {
+            portChecks.push({ name: `Port ${port}`, status: "ok" });
+        }
+    }
+    // Disk space
+    let diskInfo;
+    try {
+        const df = execSync("df -h . | tail -1", { stdio: "pipe" }).toString().trim();
+        const parts = df.split(/\s+/);
+        diskInfo = {
+            name: "Disk Space",
+            status: "ok",
+            version: `${parts[3]} available of ${parts[1]}`,
+        };
+    }
+    catch {
+        diskInfo = {
+            name: "Disk Space",
+            status: "warning",
+            message: "Could not check",
+        };
+    }
+    if (opts.json) {
+        console.log(formatJson({
+            system: sysInfo,
+            tools: results,
+            ports: portChecks,
+            disk: diskInfo,
+        }));
+        return;
+    }
+    // ── Output ──
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ System Doctor")}\n`);
+    // System info box
+    const sysContent = [
+        `${chalk.dim("OS:")}      ${sysInfo.platform} ${sysInfo.arch} (${sysInfo.release})`,
+        `${chalk.dim("CPUs:")}    ${sysInfo.cpus}`,
+        `${chalk.dim("Memory:")}  ${sysInfo.freeMemory} free / ${sysInfo.memory} total`,
+        `${chalk.dim("Disk:")}    ${diskInfo.version || diskInfo.message}`,
+        `${chalk.dim("Host:")}    ${sysInfo.hostname}`,
+    ].join("\n");
+    console.log(box(sysContent, "System"));
+    // Tools
+    const found = results.filter((r) => r.status === "ok").length;
+    const missing = results.filter((r) => r.status === "not_found").length;
+    console.log(sectionHeader(`  Tools (${chalk.green(`${String(found)} found`)}, ${missing > 0 ? chalk.red(`${String(missing)} missing`) : chalk.dim("0 missing")})`));
+    for (const r of results) {
+        console.log(formatToolCheck(r.name, r.status === "ok", r.version, INSTALL_SUGGESTIONS[r.name]));
+    }
+    // Ports
+    const portsInUse = portChecks.filter((p) => p.status === "warning");
+    console.log(sectionHeader(`  Ports (${portsInUse.length > 0 ? chalk.yellow(`${String(portsInUse.length)} in use`) : chalk.green("all available")})`));
+    for (const p of portChecks) {
+        const icon = p.status === "ok" ? chalk.green("\u2714") : chalk.yellow("\u26A0");
+        const statusText = p.status === "warning" ? chalk.yellow(p.message) : chalk.dim("available");
+        console.log(`  ${icon} ${p.name} ${statusText}`);
+    }
+    // WSL detection
+    if (sysInfo.release.includes("microsoft") || sysInfo.release.includes("WSL")) {
+        console.log(`\n  ${ICONS.warning} ${chalk.yellow("WSL detected. Docker Desktop for Windows integration recommended.")}`);
+    }
+    // Summary
+    if (missing === 0) {
+        console.log(`\n  ${chalk.green("\u2714")} ${chalk.green("All tools available. System is ready.")}\n`);
+    }
+    else {
+        console.log(`\n  ${chalk.yellow("\u26A0")} ${chalk.yellow(`${missing} tool(s) missing. Install them for full functionality.`)}\n`);
+    }
+});
+//# sourceMappingURL=doctor.js.map

package/dist/commands/down.d.ts

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

package/dist/commands/down.js

@@ -0,0 +1,37 @@
+/**
+ * stackweld down — Stop Docker services.
+ */
+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 } from "../ui/format.js";
+export const downCommand = new Command("down")
+    .description("Stop Docker services")
+    .option("-p, --path <dir>", "Project directory", ".")
+    .option("--volumes", "Remove volumes on down")
+    .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 spinner = ora("Stopping services...").start();
+    const result = runtime.down({ composePath, projectDir }, opts.volumes);
+    if (result.success) {
+        spinner.succeed(opts.volumes ? "Services stopped and volumes removed" : "Services stopped");
+    }
+    else {
+        spinner.fail("Failed to stop services");
+        console.error(chalk.dim(result.output.slice(0, 300)));
+    }
+});
+//# sourceMappingURL=down.js.map

package/dist/commands/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld env [sync|check] — Environment variable sync and safety checks.
+ */
+import { Command } from "commander";
+export declare const envCommand: Command;
+//# sourceMappingURL=env.d.ts.map

package/dist/commands/env.js

@@ -0,0 +1,129 @@
+/**
+ * stackweld env [sync|check] — Environment variable sync and safety checks.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { checkDangerous, parseEnvFile, syncEnv } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { box, error, formatJson } from "../ui/format.js";
+export const envCommand = new Command("env")
+    .description("Sync .env files and check for dangerous values")
+    .argument("[action]", "Action: sync (default) or check", "sync")
+    .option("--path <dir>", "Project directory", process.cwd())
+    .option("--json", "Output as JSON")
+    .action((action, opts) => {
+    const projectDir = path.resolve(opts.path);
+    if (action === "check") {
+        runCheck(projectDir, opts.json);
+    }
+    else if (action === "sync") {
+        runSync(projectDir, opts.json);
+    }
+    else {
+        console.error(error(`Unknown action: "${action}". Use "sync" or "check".`));
+        process.exit(1);
+    }
+});
+function runSync(projectDir, json) {
+    const examplePath = path.join(projectDir, ".env.example");
+    const envPath = path.join(projectDir, ".env");
+    if (!fs.existsSync(examplePath)) {
+        console.error(error(`No .env.example found in ${projectDir}`));
+        process.exit(1);
+    }
+    if (!fs.existsSync(envPath)) {
+        console.error(error(`No .env found in ${projectDir}`));
+        console.error(chalk.dim("  Create one from the example: cp .env.example .env"));
+        process.exit(1);
+    }
+    let exampleContent;
+    let envContent;
+    try {
+        exampleContent = fs.readFileSync(examplePath, "utf-8");
+        envContent = fs.readFileSync(envPath, "utf-8");
+    }
+    catch (err) {
+        console.error(error(`Failed to read env files: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+    const result = syncEnv(exampleContent, envContent);
+    if (json) {
+        console.log(formatJson(result));
+        return;
+    }
+    const lines = [];
+    lines.push(`${chalk.dim(".env.example:")} ${result.total.example} variables`);
+    lines.push(`${chalk.dim(".env:")}         ${result.total.actual} variables`);
+    lines.push("");
+    // Missing
+    if (result.missing.length > 0) {
+        lines.push(chalk.red(`\u2716 Missing in .env (${result.missing.length}):`));
+        for (const key of result.missing) {
+            lines.push(`  ${chalk.red(key)}`);
+        }
+    }
+    else {
+        lines.push(chalk.green("\u2714 No missing variables"));
+    }
+    lines.push("");
+    // Extra
+    if (result.extra.length > 0) {
+        lines.push(chalk.yellow(`\u26A0 Extra in .env (${result.extra.length}):`));
+        for (const key of result.extra) {
+            lines.push(`  ${chalk.yellow(key)}`);
+        }
+    }
+    else {
+        lines.push(chalk.dim("\u26A0 Extra in .env (0)"));
+    }
+    lines.push("");
+    // Dangerous
+    if (result.dangerous.length > 0) {
+        lines.push(chalk.yellow(`\u26A0 Dangerous values (${result.dangerous.length}):`));
+        for (const d of result.dangerous) {
+            lines.push(`  ${chalk.yellow(d.key)} = ${chalk.dim(`"${d.value}"`)}`);
+            lines.push(`    ${chalk.dim("\u2192")} ${d.reason}`);
+        }
+    }
+    else {
+        lines.push(chalk.green("\u2714 No dangerous values detected"));
+    }
+    console.log(box(lines.join("\n"), "Environment Sync Report"));
+}
+function runCheck(projectDir, json) {
+    const envPath = path.join(projectDir, ".env");
+    if (!fs.existsSync(envPath)) {
+        console.error(error(`No .env found in ${projectDir}`));
+        process.exit(1);
+    }
+    let envContent;
+    try {
+        envContent = fs.readFileSync(envPath, "utf-8");
+    }
+    catch (err) {
+        console.error(error(`Failed to read .env: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+    const vars = parseEnvFile(envContent);
+    const dangerous = checkDangerous(vars);
+    if (json) {
+        console.log(formatJson({ total: vars.length, dangerous }));
+        return;
+    }
+    const lines = [];
+    lines.push(`${chalk.dim("Variables:")} ${vars.length}`);
+    lines.push("");
+    if (dangerous.length > 0) {
+        lines.push(chalk.yellow(`\u26A0 Dangerous values (${dangerous.length}):`));
+        for (const d of dangerous) {
+            lines.push(`  ${chalk.yellow(d.key)} = ${chalk.dim(`"${d.value}"`)}`);
+            lines.push(`    ${chalk.dim("\u2192")} ${d.reason}`);
+        }
+    }
+    else {
+        lines.push(chalk.green("\u2714 No dangerous values detected"));
+    }
+    console.log(box(lines.join("\n"), "Environment Check"));
+}
+//# sourceMappingURL=env.js.map

package/dist/commands/export-stack.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld export <stack-id> — Export a stack definition to YAML or JSON.
+ */
+import { Command } from "commander";
+export declare const exportCommand: Command;
+//# sourceMappingURL=export-stack.d.ts.map

package/dist/commands/export-stack.js

@@ -0,0 +1,51 @@
+/**
+ * stackweld export <stack-id> — Export a stack definition to YAML or JSON.
+ */
+import * as fs from "node:fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import { stringify as yamlStringify } from "yaml";
+import { getStackEngine } from "../ui/context.js";
+export const exportCommand = new Command("export")
+    .description("Export a stack definition to YAML or JSON")
+    .argument("<id>", "Stack ID")
+    .option("-f, --format <fmt>", "Output format: json or yaml", "yaml")
+    .option("-o, --output <file>", "Output file (default: stdout)")
+    .action((id, opts) => {
+    const engine = getStackEngine();
+    const stack = engine.get(id);
+    if (!stack) {
+        console.error(chalk.red(`Stack "${id}" not found.`));
+        process.exit(1);
+    }
+    // Build portable export object (without internal IDs)
+    const exportData = {
+        name: stack.name,
+        description: stack.description,
+        profile: stack.profile,
+        version: stack.version,
+        tags: stack.tags,
+        technologies: stack.technologies.map((t) => ({
+            id: t.technologyId,
+            version: t.version,
+            port: t.port,
+        })),
+        exportedAt: new Date().toISOString(),
+        exportedBy: "stackweld",
+    };
+    let output;
+    if (opts.format === "json") {
+        output = JSON.stringify(exportData, null, 2);
+    }
+    else {
+        output = yamlStringify(exportData);
+    }
+    if (opts.output) {
+        fs.writeFileSync(opts.output, output, "utf-8");
+        console.log(chalk.green(`✓ Exported to ${opts.output}`));
+    }
+    else {
+        console.log(output);
+    }
+});
+//# sourceMappingURL=export-stack.js.map

package/dist/commands/generate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * stackweld generate — Smart project generator.
+ * Detects project type (full-stack, frontend-only, backend-only),
+ * creates proper directory structure, executes official scaffolds,
+ * generates per-directory .env files, and leaves everything ready to code.
+ */
+import { Command } from "commander";
+export declare const generateCommand: Command;
+//# sourceMappingURL=generate.d.ts.map