@stackweld/cli 0.2.0

package/dist/__tests__/commands.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commands.test.d.ts.map

package/dist/__tests__/commands.test.js

@@ -0,0 +1,275 @@
+import { describe, expect, it } from "vitest";
+import { banner, box, emptyState, error, info, progressBar, stepIndicator, success, table, warning, } from "../ui/format.js";
+// Helper to strip ANSI escape codes for content assertions
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+// ─── format.ts utility functions ─────────────────────────
+describe("format.ts utility functions", () => {
+    describe("success()", () => {
+        it("returns string containing green checkmark", () => {
+            const result = success("done");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("\u2714");
+            expect(plain).toContain("done");
+        });
+        it("includes the message text", () => {
+            const result = success("All tests passed");
+            expect(stripAnsi(result)).toContain("All tests passed");
+        });
+    });
+    describe("error()", () => {
+        it("returns string containing red X", () => {
+            const result = error("failed");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("\u2716");
+            expect(plain).toContain("failed");
+        });
+        it("includes the message text", () => {
+            const result = error("Build failed");
+            expect(stripAnsi(result)).toContain("Build failed");
+        });
+    });
+    describe("warning()", () => {
+        it("returns string containing warning triangle", () => {
+            const result = warning("careful");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("\u26A0");
+            expect(plain).toContain("careful");
+        });
+    });
+    describe("info()", () => {
+        it("returns string containing info symbol", () => {
+            const result = info("note");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("\u2139");
+            expect(plain).toContain("note");
+        });
+    });
+    describe("banner()", () => {
+        it("returns formatted banner with version", () => {
+            const result = banner("1.0.0");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("Stackweld");
+            expect(plain).toContain("v1.0.0");
+        });
+        it("includes tagline", () => {
+            const result = banner("2.0.0");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("operating system for your dev stacks");
+        });
+        it("returns multi-line output", () => {
+            const result = banner("1.0.0");
+            const lines = result.split("\n");
+            expect(lines.length).toBeGreaterThan(1);
+        });
+    });
+    describe("box()", () => {
+        it("draws Unicode box around content", () => {
+            const result = box("hello");
+            expect(result).toContain("\u256D"); // top-left corner
+            expect(result).toContain("\u256E"); // top-right corner
+            expect(result).toContain("\u2570"); // bottom-left corner
+            expect(result).toContain("\u256F"); // bottom-right corner
+            expect(result).toContain("\u2502"); // vertical bar
+            expect(result).toContain("\u2500"); // horizontal bar
+        });
+        it("includes the content inside the box", () => {
+            const result = box("test content");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("test content");
+        });
+        it("supports an optional title", () => {
+            const result = box("body", "Title");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("Title");
+            expect(plain).toContain("body");
+        });
+        it("handles multi-line content", () => {
+            const result = box("line1\nline2\nline3");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("line1");
+            expect(plain).toContain("line2");
+            expect(plain).toContain("line3");
+        });
+    });
+    describe("table()", () => {
+        it("formats data in aligned columns", () => {
+            const data = [
+                { name: "Next.js", category: "frontend" },
+                { name: "PostgreSQL", category: "database" },
+            ];
+            const columns = [
+                { header: "Name", key: "name" },
+                { header: "Category", key: "category" },
+            ];
+            const result = table(data, columns);
+            const plain = stripAnsi(result);
+            expect(plain).toContain("Name");
+            expect(plain).toContain("Category");
+            expect(plain).toContain("Next.js");
+            expect(plain).toContain("PostgreSQL");
+            expect(plain).toContain("frontend");
+            expect(plain).toContain("database");
+        });
+        it("returns empty string for empty data", () => {
+            const result = table([], [{ header: "Name", key: "name" }]);
+            expect(result).toBe("");
+        });
+        it("includes a separator line between header and data", () => {
+            const data = [{ name: "test" }];
+            const columns = [{ header: "Name", key: "name" }];
+            const result = table(data, columns);
+            const plain = stripAnsi(result);
+            const lines = plain.split("\n");
+            // line 0 = header, line 1 = separator, line 2+ = data
+            expect(lines.length).toBeGreaterThanOrEqual(3);
+            expect(lines[1]).toMatch(/\u2500+/);
+        });
+        it("handles missing keys gracefully", () => {
+            const data = [{ name: "test" }];
+            const columns = [
+                { header: "Name", key: "name" },
+                { header: "Missing", key: "nonexistent" },
+            ];
+            const result = table(data, columns);
+            // Should not throw, just produce empty value
+            expect(stripAnsi(result)).toContain("Name");
+        });
+    });
+    describe("stepIndicator()", () => {
+        it("shows correct step count", () => {
+            const result = stepIndicator(2, 5, "Processing");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("[2/5]");
+            expect(plain).toContain("Processing");
+        });
+        it("works with step 1 of 1", () => {
+            const result = stepIndicator(1, 1, "Only step");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("[1/1]");
+            expect(plain).toContain("Only step");
+        });
+    });
+    describe("emptyState()", () => {
+        it("returns formatted empty message", () => {
+            const result = emptyState("No items found");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("No items found");
+        });
+        it("includes hint when provided", () => {
+            const result = emptyState("No stacks", "Run stackweld create to get started");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("No stacks");
+            expect(plain).toContain("Run stackweld create to get started");
+        });
+        it("works without hint", () => {
+            const result = emptyState("Empty");
+            const plain = stripAnsi(result);
+            expect(plain).toContain("Empty");
+            // Should not throw
+        });
+    });
+    describe("progressBar()", () => {
+        it("shows 0% for zero progress", () => {
+            const result = progressBar(0, 10);
+            const plain = stripAnsi(result);
+            expect(plain).toContain("0%");
+        });
+        it("shows 50% for half progress", () => {
+            const result = progressBar(5, 10);
+            const plain = stripAnsi(result);
+            expect(plain).toContain("50%");
+        });
+        it("shows 100% for complete progress", () => {
+            const result = progressBar(10, 10);
+            const plain = stripAnsi(result);
+            expect(plain).toContain("100%");
+        });
+        it("caps at 100% when current exceeds total", () => {
+            const result = progressBar(15, 10);
+            const plain = stripAnsi(result);
+            expect(plain).toContain("100%");
+        });
+        it("contains filled and empty bar characters", () => {
+            const result = progressBar(5, 10, 20);
+            // Should contain both filled (\u2588) and empty (\u2591) blocks
+            expect(result).toContain("\u2588");
+            expect(result).toContain("\u2591");
+        });
+        it("respects custom width", () => {
+            const result = progressBar(5, 10, 40);
+            // The bar portion should contain 40 total bar characters
+            const filled = (result.match(/\u2588/g) || []).length;
+            const empty = (result.match(/\u2591/g) || []).length;
+            expect(filled + empty).toBe(40);
+        });
+    });
+});
+// ─── Input validation (from generate.ts) ────────────────
+import * as nodePath from "node:path";
+describe("Input validation for project names", () => {
+    // Replicate the validation logic from generate.ts (lines 426-429):
+    // const safeName = path.basename(opts.name);
+    // if (safeName !== opts.name || !/^[a-zA-Z0-9_.\-]+$/.test(safeName))
+    const path = nodePath;
+    function isValidProjectName(name) {
+        const safeName = path.basename(name);
+        return safeName === name && /^[a-zA-Z0-9_.-]+$/.test(safeName);
+    }
+    describe("rejects path traversal attempts", () => {
+        it("rejects ../evil", () => {
+            expect(isValidProjectName("../evil")).toBe(false);
+        });
+        it("rejects ../../etc/passwd", () => {
+            expect(isValidProjectName("../../etc/passwd")).toBe(false);
+        });
+        it("rejects subdir/project", () => {
+            expect(isValidProjectName("subdir/project")).toBe(false);
+        });
+    });
+    describe("rejects shell injection characters", () => {
+        it("rejects names with semicolons", () => {
+            expect(isValidProjectName("project;rm -rf")).toBe(false);
+        });
+        it("rejects names with pipes", () => {
+            expect(isValidProjectName("project|evil")).toBe(false);
+        });
+        it("rejects names with dollar signs", () => {
+            expect(isValidProjectName("project$HOME")).toBe(false);
+        });
+        it("rejects names with backticks", () => {
+            expect(isValidProjectName("project`whoami`")).toBe(false);
+        });
+        it("rejects names with spaces", () => {
+            expect(isValidProjectName("my project")).toBe(false);
+        });
+        it("rejects empty string", () => {
+            expect(isValidProjectName("")).toBe(false);
+        });
+    });
+    describe("accepts valid project names", () => {
+        it("accepts my-project", () => {
+            expect(isValidProjectName("my-project")).toBe(true);
+        });
+        it("accepts test_app", () => {
+            expect(isValidProjectName("test_app")).toBe(true);
+        });
+        it("accepts app1", () => {
+            expect(isValidProjectName("app1")).toBe(true);
+        });
+        it("accepts names with dots", () => {
+            expect(isValidProjectName("my.app")).toBe(true);
+        });
+        it("accepts uppercase letters", () => {
+            expect(isValidProjectName("MyProject")).toBe(true);
+        });
+        it("accepts single character", () => {
+            expect(isValidProjectName("a")).toBe(true);
+        });
+        it("accepts numbers only", () => {
+            expect(isValidProjectName("123")).toBe(true);
+        });
+    });
+});
+//# sourceMappingURL=commands.test.js.map

package/dist/commands/ai.d.ts

@@ -0,0 +1,8 @@
+/**
+ * stackweld ai — AI-powered utilities.
+ * These are utility features, NOT the source of truth for compatibility.
+ * Uses the Anthropic API for natural language processing.
+ */
+import { Command } from "commander";
+export declare const aiCommand: Command;
+//# sourceMappingURL=ai.d.ts.map

package/dist/commands/ai.js

@@ -0,0 +1,167 @@
+/**
+ * stackweld ai — AI-powered utilities.
+ * These are utility features, NOT the source of truth for compatibility.
+ * Uses the Anthropic API for natural language processing.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { box, error } from "../ui/format.js";
+function getClient() {
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey)
+        return null;
+    return new Anthropic({ apiKey });
+}
+function requireApiKey() {
+    const client = getClient();
+    if (!client) {
+        console.error("");
+        console.error(error("ANTHROPIC_API_KEY is not set."));
+        console.error("");
+        console.error(chalk.dim("  To use AI features, set your API key:"));
+        console.error(chalk.dim("    export ANTHROPIC_API_KEY=sk-ant-..."));
+        console.error("");
+        console.error(chalk.dim("  Get one at: https://console.anthropic.com/settings/keys"));
+        console.error("");
+        process.exit(1);
+    }
+    return client;
+}
+async function ask(client, systemPrompt, userPrompt) {
+    const response = await client.messages.create({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 1024,
+        system: systemPrompt,
+        messages: [{ role: "user", content: userPrompt }],
+    });
+    const block = response.content[0];
+    return block.type === "text" ? block.text : "";
+}
+export const aiCommand = new Command("ai")
+    .description("AI-powered utilities (requires ANTHROPIC_API_KEY)")
+    .addCommand(new Command("suggest")
+    .description("Suggest a stack from a natural language description")
+    .argument("<description>", "What you want to build")
+    .action(async (description) => {
+    const client = requireApiKey();
+    const rules = getRulesEngine();
+    const allTechs = rules.getAllTechnologies();
+    const techList = allTechs.map((t) => `${t.id} (${t.name}, ${t.category})`).join("\n");
+    const spinner = ora("Thinking...").start();
+    try {
+        const result = await ask(client, `You are Stackweld AI. You suggest technology stacks from a catalog.
+Available technologies (use ONLY these IDs):
+${techList}
+
+Respond with:
+1. A stack name
+2. Profile (rapid/standard/production/enterprise/lightweight)
+3. Technology IDs as a comma-separated list
+4. Brief explanation of why each technology was chosen
+
+Be concise. Only suggest technologies from the list above.`, `I want to build: ${description}`);
+        spinner.stop();
+        console.log("");
+        console.log(box(result, "Suggested Stack"));
+        console.log("");
+        console.log(chalk.dim("  To create this stack: stackweld generate --name <name> --path . --techs <ids>"));
+        console.log("");
+    }
+    catch (err) {
+        spinner.fail("AI request failed");
+        if (err instanceof Error) {
+            if (err.message.includes("401") || err.message.includes("authentication")) {
+                console.error(error("Invalid API key. Check your ANTHROPIC_API_KEY."));
+            }
+            else if (err.message.includes("429")) {
+                console.error(error("Rate limited. Try again in a moment."));
+            }
+            else {
+                console.error(chalk.dim(`  ${err.message}`));
+            }
+        }
+    }
+}))
+    .addCommand(new Command("readme")
+    .description("Generate a README from a saved stack")
+    .argument("<stack-id>", "Stack ID")
+    .action(async (stackId) => {
+    const client = requireApiKey();
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(error(`Stack "${stackId}" not found.`));
+        console.error(chalk.dim("  Run `stackweld list` to see saved stacks."));
+        process.exit(1);
+    }
+    const techDetails = stack.technologies
+        .map((st) => {
+        const tech = rules.getTechnology(st.technologyId);
+        return tech
+            ? `- ${tech.name} v${st.version} (${tech.category}): ${tech.description}`
+            : `- ${st.technologyId} v${st.version}`;
+    })
+        .join("\n");
+    const spinner = ora("Generating README...").start();
+    try {
+        const result = await ask(client, `You generate professional README.md files for software projects. Write clean, practical Markdown. No emojis.`, `Generate a README.md for a project called "${stack.name}" (${stack.description || "no description"}).
+Profile: ${stack.profile}
+Technologies:
+${techDetails}
+
+Include: project description, tech stack table, getting started (with docker compose up, env setup), development commands, and project structure suggestions.`);
+        spinner.stop();
+        console.log(result);
+    }
+    catch (err) {
+        spinner.fail("AI request failed");
+        console.error(chalk.dim(err instanceof Error ? err.message : String(err)));
+    }
+}))
+    .addCommand(new Command("explain")
+    .description("Explain the decisions in a stack")
+    .argument("<stack-id>", "Stack ID")
+    .action(async (stackId) => {
+    const client = requireApiKey();
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(error(`Stack "${stackId}" not found.`));
+        console.error(chalk.dim("  Run `stackweld list` to see saved stacks."));
+        process.exit(1);
+    }
+    const techDetails = stack.technologies
+        .map((st) => {
+        const tech = rules.getTechnology(st.technologyId);
+        return tech ? `${tech.name} (${tech.category})` : st.technologyId;
+    })
+        .join(", ");
+    const spinner = ora("Analyzing stack...").start();
+    try {
+        const result = await ask(client, `You are a senior software architect. Explain technology choices concisely. No emojis.`, `Explain the architecture decisions in this stack:
+Name: ${stack.name}
+Profile: ${stack.profile}
+Technologies: ${techDetails}
+
+For each technology, explain:
+1. Why it was likely chosen
+2. How it fits with the other pieces
+3. Any trade-offs to be aware of
+
+Be concise and practical.`);
+        spinner.stop();
+        console.log("");
+        console.log(box(result, "Stack Analysis"));
+        console.log("");
+    }
+    catch (err) {
+        spinner.fail("AI request failed");
+        console.error(chalk.dim(err instanceof Error ? err.message : String(err)));
+    }
+}));
+//# sourceMappingURL=ai.js.map

package/dist/commands/analyze.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld analyze [path] — Detect the technology stack of a project.
+ */
+import { Command } from "commander";
+export declare const analyzeCommand: Command;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/commands/analyze.js

@@ -0,0 +1,90 @@
+/**
+ * stackweld analyze [path] — Detect the technology stack of a project.
+ */
+import * as path from "node:path";
+import { detectStack } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { box, error, formatJson, success } from "../ui/format.js";
+const PROJECT_TYPE_LABELS = {
+    frontend: "Frontend",
+    backend: "Backend",
+    fullstack: "Full-Stack",
+    monorepo: "Monorepo",
+    library: "Library",
+    unknown: "Unknown",
+};
+export const analyzeCommand = new Command("analyze")
+    .description("Detect the technology stack of a project")
+    .argument("[path]", "Project directory to analyze", process.cwd())
+    .option("--import", "Save detected stack to the database")
+    .option("--json", "Output as JSON")
+    .action((targetPath, opts) => {
+    const projectDir = path.resolve(targetPath);
+    let result;
+    try {
+        result = detectStack(projectDir);
+    }
+    catch (err) {
+        console.error(error(`Failed to analyze project: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+    }
+    if (opts.json) {
+        console.log(formatJson(result));
+        return;
+    }
+    const lines = [];
+    // Project type
+    const typeLabel = PROJECT_TYPE_LABELS[result.projectType] || result.projectType;
+    lines.push(`${chalk.dim("Project Type:")} ${chalk.bold(typeLabel)} ${chalk.dim(`(${result.confidence}%)`)}`);
+    lines.push("");
+    // Technologies
+    if (result.technologies.length > 0) {
+        lines.push(chalk.bold("Detected Technologies:"));
+        for (const tech of result.technologies) {
+            const version = tech.version ? ` ${tech.version}` : "";
+            const via = chalk.dim(`(${tech.detectedVia})`);
+            lines.push(`${chalk.green("\u2714")}  ${chalk.cyan(tech.name)}${chalk.dim(version)}  ${via}`);
+        }
+    }
+    else {
+        lines.push(chalk.dim("No technologies detected."));
+    }
+    lines.push("");
+    // Package managers
+    if (result.packageManagers.length > 0) {
+        lines.push(`${chalk.dim("Package Managers:")} ${result.packageManagers.join(", ")}`);
+        lines.push("");
+    }
+    // Summary
+    const count = result.technologies.length;
+    lines.push(`${count} ${count === 1 ? "technology" : "technologies"} ${chalk.dim("\u2022")} Confidence: ${result.confidence}%`);
+    if (!opts.import) {
+        lines.push("");
+        lines.push(chalk.dim("Run with --import to save as a stack"));
+    }
+    console.log(box(lines.join("\n"), `Stack Detection: ${projectDir}`));
+    // Import mode
+    if (opts.import) {
+        try {
+            const engine = getStackEngine();
+            const stackTechs = result.technologies.map((t) => ({
+                technologyId: t.id,
+                version: t.version || "latest",
+            }));
+            const dirName = path.basename(projectDir);
+            const { stack } = engine.create({
+                name: dirName,
+                profile: "standard",
+                technologies: stackTechs,
+            });
+            console.log(success(`Stack saved: ${stack.name} (${stack.id})`));
+        }
+        catch (err) {
+            console.error(error(`Failed to save stack: ${err instanceof Error ? err.message : String(err)}`));
+            process.exit(1);
+        }
+    }
+});
+//# sourceMappingURL=analyze.js.map

package/dist/commands/benchmark.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld benchmark <stackId> — Show performance profile for a saved stack.
+ */
+import { Command } from "commander";
+export declare const benchmarkCommand: Command;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/commands/benchmark.js

@@ -0,0 +1,86 @@
+/**
+ * stackweld benchmark <stackId> — Show performance profile for a saved stack.
+ */
+import { profilePerformance } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { box, formatJson, gradientHeader } from "../ui/format.js";
+const RATING_COLORS = {
+    blazing: (s) => chalk.green.bold(s),
+    fast: (s) => chalk.cyan.bold(s),
+    moderate: (s) => chalk.yellow.bold(s),
+    heavy: (s) => chalk.red.bold(s),
+};
+const PERF_COLORS = {
+    fast: (s) => chalk.green(s),
+    moderate: (s) => chalk.yellow(s),
+    heavy: (s) => chalk.red(s),
+};
+const RATING_ICONS = {
+    blazing: "\u26A1",
+    fast: "\u2714",
+    moderate: "\u25CF",
+    heavy: "\u26A0",
+};
+export const benchmarkCommand = new Command("benchmark")
+    .description("Show performance profile for a saved stack")
+    .argument("<stack-id>", "Stack ID to profile")
+    .option("--json", "Output as JSON")
+    .action((stackId, opts) => {
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    const stack = engine.get(stackId);
+    if (!stack) {
+        console.error(chalk.red(`\u2716 Stack "${stackId}" not found.`));
+        console.error(chalk.dim("  Run: stackweld list"));
+        process.exit(1);
+    }
+    // Resolve full technology data
+    const technologies = stack.technologies
+        .map((st) => rules.getTechnology(st.technologyId))
+        .filter((t) => t !== undefined);
+    if (technologies.length === 0) {
+        console.error(chalk.red("\u2716 No technologies could be resolved for this stack."));
+        process.exit(1);
+    }
+    const profile = profilePerformance(technologies);
+    if (opts.json) {
+        console.log(formatJson(profile));
+        return;
+    }
+    // ── Format output ──
+    const ratingColor = RATING_COLORS[profile.rating] || chalk.white;
+    const ratingIcon = RATING_ICONS[profile.rating] || "";
+    const lines = [];
+    lines.push("");
+    lines.push(`  ${chalk.dim("Rating:")}      ${ratingIcon} ${ratingColor(profile.rating.toUpperCase())}`);
+    lines.push(`  ${chalk.dim("Req/s:")}       ${chalk.bold(profile.estimatedReqPerSec)}`);
+    lines.push(`  ${chalk.dim("Cold start:")}  ${profile.estimatedColdStart}`);
+    lines.push(`  ${chalk.dim("Memory:")}      ${profile.estimatedMemory}`);
+    lines.push("");
+    // Per-technology breakdown
+    if (profile.techProfiles.length > 0) {
+        lines.push(`  ${chalk.bold("Technology Breakdown:")}`);
+        lines.push("");
+        for (const tp of profile.techProfiles) {
+            const perfColor = PERF_COLORS[tp.perf] || chalk.white;
+            const perfLabel = perfColor(tp.perf.toUpperCase().padEnd(8));
+            lines.push(`  ${perfLabel} ${chalk.cyan(tp.name)} ${chalk.dim(`(${tp.category})`)}`);
+            lines.push(`           ${chalk.dim(tp.note)}`);
+        }
+        lines.push("");
+    }
+    // Notes
+    if (profile.notes.length > 0) {
+        lines.push(`  ${chalk.bold("Notes:")}`);
+        for (const note of profile.notes) {
+            lines.push(`  ${chalk.dim("\u2192")} ${chalk.dim(note)}`);
+        }
+        lines.push("");
+    }
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Benchmark")}\n`);
+    console.log(box(lines.join("\n"), `Performance: ${stack.name}`));
+    console.log("");
+});
+//# sourceMappingURL=benchmark.js.map

package/dist/commands/browse.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld browse — Browse the technology catalog and templates.
+ */
+import { Command } from "commander";
+export declare const browseCommand: Command;
+//# sourceMappingURL=browse.d.ts.map