@stackweld/cli 0.2.0

package/dist/commands/import-stack.js

@@ -0,0 +1,68 @@
+/**
+ * stackweld import <file> — Import a stack definition from YAML or JSON.
+ */
+import * as fs from "node:fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import { parse as yamlParse } from "yaml";
+import { getStackEngine } from "../ui/context.js";
+import { formatStackRow, formatValidation } from "../ui/format.js";
+export const importCommand = new Command("import")
+    .description("Import a stack definition from a YAML or JSON file")
+    .argument("<file>", "Path to the YAML or JSON file")
+    .option("--json", "Output result as JSON")
+    .action((file, opts) => {
+    if (!fs.existsSync(file)) {
+        console.error(chalk.red(`File not found: ${file}`));
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(file, "utf-8");
+    let data;
+    // Detect format
+    if (file.endsWith(".json")) {
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            console.error(chalk.red("Invalid JSON file."));
+            process.exit(1);
+        }
+    }
+    else {
+        // Try YAML (also handles JSON since JSON is valid YAML)
+        try {
+            data = yamlParse(raw);
+        }
+        catch {
+            console.error(chalk.red("Invalid YAML/JSON file."));
+            process.exit(1);
+        }
+    }
+    if (!data.name || !data.technologies || !Array.isArray(data.technologies)) {
+        console.error(chalk.red("Invalid stack file. Required: name, technologies array."));
+        process.exit(1);
+    }
+    const engine = getStackEngine();
+    const technologies = data.technologies.map((t) => ({
+        technologyId: t.id,
+        version: t.version,
+        port: t.port,
+    }));
+    const { stack, validation } = engine.create({
+        name: data.name,
+        description: data.description,
+        profile: data.profile || "standard",
+        technologies,
+        tags: data.tags,
+    });
+    console.log(formatValidation(validation));
+    console.log("");
+    if (opts.json) {
+        console.log(JSON.stringify({ stack, validation }, null, 2));
+    }
+    else {
+        console.log(formatStackRow(stack));
+        console.log(chalk.green(`\n✓ Imported "${stack.name}" successfully`));
+    }
+});
+//# sourceMappingURL=import-stack.js.map

package/dist/commands/info.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld info <id> — Show detailed information about a stack or technology.
+ */
+import { Command } from "commander";
+export declare const infoCommand: Command;
+//# sourceMappingURL=info.d.ts.map

package/dist/commands/info.js

@@ -0,0 +1,56 @@
+/**
+ * stackweld info <id> — Show detailed information about a stack or technology.
+ */
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { formatJson, formatStackRow, formatTechnology } from "../ui/format.js";
+export const infoCommand = new Command("info")
+    .description("Show details about a stack or technology")
+    .argument("<id>", "Stack ID or technology ID")
+    .option("--json", "Output as JSON")
+    .action((id, opts) => {
+    const engine = getStackEngine();
+    const rules = getRulesEngine();
+    // Try stack first
+    const stack = engine.get(id);
+    if (stack) {
+        if (opts.json) {
+            console.log(formatJson(stack));
+        }
+        else {
+            console.log(formatStackRow(stack));
+            // Show individual tech details
+            console.log(chalk.bold("\nTechnologies:"));
+            for (const t of stack.technologies) {
+                const tech = rules.getTechnology(t.technologyId);
+                if (tech) {
+                    console.log(`  ${chalk.cyan(tech.name)} ${chalk.dim(`v${t.version}`)} ${t.port ? chalk.dim(`:${t.port}`) : ""}`);
+                }
+            }
+            // Show version history
+            const history = engine.getVersionHistory(stack.id);
+            if (history.length > 1) {
+                console.log(chalk.bold("\nVersion history:"));
+                for (const v of history.slice(0, 5)) {
+                    console.log(`  ${chalk.dim(`v${v.version}`)} ${chalk.dim(v.timestamp)} ${v.changelog}`);
+                }
+            }
+        }
+        return;
+    }
+    // Try technology
+    const tech = rules.getTechnology(id);
+    if (tech) {
+        if (opts.json) {
+            console.log(formatJson(tech));
+        }
+        else {
+            console.log(formatTechnology(tech));
+        }
+        return;
+    }
+    console.error(chalk.red(`"${id}" not found as stack or technology.`));
+    process.exit(1);
+});
+//# sourceMappingURL=info.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld init — Initialize Stackweld in the current directory or interactively create a new stack.
+ */
+import { Command } from "commander";
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -0,0 +1,186 @@
+/**
+ * stackweld init — Initialize Stackweld in the current directory or interactively create a new stack.
+ */
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { getAllTemplates } from "@stackweld/templates";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine, getStackEngine } from "../ui/context.js";
+import { formatStackSummary, formatValidation, gradientHeader, nextSteps, stepIndicator, warning, } from "../ui/format.js";
+export const initCommand = new Command("init")
+    .description("Create a new stack interactively")
+    .option("--template <id>", "Start from a template")
+    .option("--json", "Output result as JSON")
+    .action(async (opts) => {
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ New Stack Wizard")}\n`);
+    const rules = getRulesEngine();
+    const engine = getStackEngine();
+    // ── Step 1: Choose mode ──
+    console.log(stepIndicator(1, 5, "Choose how to start"));
+    const mode = opts.template
+        ? "template"
+        : await select({
+            message: "How do you want to start?",
+            choices: [
+                { name: "From scratch — pick technologies one by one", value: "scratch" },
+                { name: "From a template — use a pre-built stack", value: "template" },
+            ],
+        });
+    let technologies = [];
+    let profile = "standard";
+    let stackName = "";
+    if (mode === "template") {
+        // ── Step 2: Select template ──
+        console.log(`\n${stepIndicator(2, 5, "Select template")}`);
+        const templates = getAllTemplates();
+        if (templates.length === 0) {
+            console.log(warning("No templates available. Run from scratch instead."));
+            return;
+        }
+        const templateId = opts.template ||
+            (await select({
+                message: "Choose a template:",
+                choices: templates.map((t) => ({
+                    name: `${chalk.cyan(t.name)} ${chalk.dim("—")} ${t.description}`,
+                    value: t.id,
+                })),
+            }));
+        const template = templates.find((t) => t.id === templateId);
+        if (!template) {
+            console.error(chalk.red(`\u2716 Template "${templateId}" not found.`));
+            console.error(chalk.dim(`  Available templates: ${templates.map((t) => t.id).join(", ")}`));
+            process.exit(1);
+        }
+        // ── Step 3: Name ──
+        console.log(`\n${stepIndicator(3, 5, "Name your project")}`);
+        stackName = await input({
+            message: "Project name:",
+            default: template.variables.projectName || "my-project",
+            validate: (v) => (v.trim().length > 0 ? true : "Name cannot be empty"),
+        });
+        technologies = template.technologyIds.map((tid) => {
+            const tech = rules.getTechnology(tid);
+            return {
+                technologyId: tid,
+                version: tech?.defaultVersion || "latest",
+            };
+        });
+        profile = template.profile;
+        // Steps 4-5 skipped for template mode
+        console.log(`\n${stepIndicator(4, 5, chalk.dim("Profile: ") + profile)}`);
+        console.log(`${stepIndicator(5, 5, `${chalk.dim("Technologies: ") + technologies.length} from template`)}`);
+    }
+    else {
+        // ── Step 2: Name ──
+        console.log(`\n${stepIndicator(2, 5, "Name your stack")}`);
+        stackName = await input({
+            message: "Stack name:",
+            default: "my-stack",
+            validate: (v) => (v.trim().length > 0 ? true : "Name cannot be empty"),
+        });
+        // ── Step 3: Profile ──
+        console.log(`\n${stepIndicator(3, 5, "Choose a project profile")}`);
+        profile = (await select({
+            message: "Project profile:",
+            choices: [
+                {
+                    name: `${chalk.cyan("Rapid")}      ${chalk.dim("— Quick prototyping, minimal config")}`,
+                    value: "rapid",
+                },
+                {
+                    name: `${chalk.cyan("Standard")}   ${chalk.dim("— Balanced defaults for most projects")}`,
+                    value: "standard",
+                },
+                {
+                    name: `${chalk.cyan("Production")} ${chalk.dim("— Battle-tested, monitoring included")}`,
+                    value: "production",
+                },
+                {
+                    name: `${chalk.cyan("Enterprise")} ${chalk.dim("— Full compliance, audit, security")}`,
+                    value: "enterprise",
+                },
+                {
+                    name: `${chalk.cyan("Lightweight")}${chalk.dim("— Minimal footprint")}`,
+                    value: "lightweight",
+                },
+            ],
+        }));
+        // ── Step 4: Technologies ──
+        console.log(`\n${stepIndicator(4, 5, "Select technologies by category")}`);
+        const categories = [
+            "runtime",
+            "frontend",
+            "backend",
+            "database",
+            "orm",
+            "auth",
+            "styling",
+            "service",
+            "devops",
+        ];
+        for (const category of categories) {
+            const available = rules.getByCategory(category);
+            if (available.length === 0)
+                continue;
+            const selected = await checkbox({
+                message: `${chalk.cyan(category)} technologies:`,
+                choices: available.map((t) => ({
+                    name: `${t.name} ${chalk.dim(`(${t.defaultVersion})`)}`,
+                    value: t.id,
+                })),
+            });
+            for (const id of selected) {
+                const tech = rules.getTechnology(id);
+                if (tech) {
+                    technologies.push({
+                        technologyId: id,
+                        version: tech.defaultVersion,
+                    });
+                }
+            }
+        }
+        // ── Step 5: Confirm ──
+        console.log(`\n${stepIndicator(5, 5, "Review and confirm")}`);
+    }
+    if (technologies.length === 0) {
+        console.log(warning("No technologies selected. Aborting."));
+        return;
+    }
+    // Show summary before creating
+    console.log("");
+    console.log(chalk.bold("  Summary:"));
+    console.log(`  ${chalk.dim("Name:")}     ${chalk.cyan(stackName)}`);
+    console.log(`  ${chalk.dim("Profile:")}  ${profile}`);
+    console.log(`  ${chalk.dim("Techs:")}    ${technologies.map((t) => t.technologyId).join(", ")}`);
+    console.log("");
+    if (mode !== "template") {
+        const proceed = await confirm({
+            message: "Create this stack?",
+            default: true,
+        });
+        if (!proceed) {
+            console.log(chalk.dim("  Cancelled."));
+            return;
+        }
+    }
+    const { stack, validation } = engine.create({
+        name: stackName,
+        profile,
+        technologies,
+    });
+    console.log("");
+    console.log(formatValidation(validation));
+    console.log("");
+    if (opts.json) {
+        console.log(JSON.stringify({ stack, validation }, null, 2));
+    }
+    else {
+        console.log(formatStackSummary(stack));
+        console.log(nextSteps([
+            `stackweld scaffold ${stack.id} --path .`,
+            `stackweld generate --name ${stackName} --path . --techs ${technologies.map((t) => t.technologyId).join(",")}`,
+            `stackweld info ${stack.id}`,
+        ]));
+    }
+});
+//# sourceMappingURL=init.js.map

package/dist/commands/learn.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld learn <technology> — Show learning resources for a technology.
+ */
+import { Command } from "commander";
+export declare const learnCommand: Command;
+//# sourceMappingURL=learn.d.ts.map

package/dist/commands/learn.js

@@ -0,0 +1,91 @@
+/**
+ * stackweld learn <technology> — Show learning resources for a technology.
+ */
+import { getLearningResources } from "@stackweld/registry";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getRulesEngine } from "../ui/context.js";
+import { box } from "../ui/format.js";
+const DIFFICULTY_ICONS = {
+    beginner: "\u{1F4D6}", // open book
+    intermediate: "\u{1F4DA}", // books
+    advanced: "\u{1F393}", // graduation cap
+};
+const DIFFICULTY_ORDER = {
+    beginner: 0,
+    intermediate: 1,
+    advanced: 2,
+};
+const DIFFICULTY_LABELS = {
+    beginner: "Beginner",
+    intermediate: "Intermediate",
+    advanced: "Advanced",
+};
+export const learnCommand = new Command("learn")
+    .description("Show learning resources for a technology")
+    .argument("<technology>", "Technology ID (e.g. nextjs, react, docker)")
+    .option("--json", "Output as JSON")
+    .action((technologyId, opts) => {
+    const rules = getRulesEngine();
+    const tech = rules.getTechnology(technologyId);
+    const resources = getLearningResources(technologyId);
+    const displayName = tech?.name ?? technologyId;
+    if (!resources || resources.length === 0) {
+        if (opts.json) {
+            console.log(JSON.stringify({ technology: technologyId, resources: [] }, null, 2));
+            return;
+        }
+        console.log("");
+        console.log(chalk.yellow(`  No learning resources found for "${technologyId}".`));
+        console.log("");
+        console.log(chalk.dim("  Try searching the official website or documentation."));
+        if (tech?.website) {
+            console.log(chalk.dim(`  Website: ${chalk.cyan(tech.website)}`));
+        }
+        console.log("");
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ technology: technologyId, name: displayName, resources }, null, 2));
+        return;
+    }
+    // Group resources by difficulty
+    const grouped = {};
+    for (const resource of resources) {
+        if (!grouped[resource.difficulty]) {
+            grouped[resource.difficulty] = [];
+        }
+        grouped[resource.difficulty].push(resource);
+    }
+    const lines = [];
+    lines.push("");
+    let counter = 1;
+    const difficulties = Object.keys(grouped).sort((a, b) => (DIFFICULTY_ORDER[a] ?? 99) - (DIFFICULTY_ORDER[b] ?? 99));
+    for (const difficulty of difficulties) {
+        const icon = DIFFICULTY_ICONS[difficulty] ?? "";
+        const label = DIFFICULTY_LABELS[difficulty] ?? difficulty;
+        lines.push(`  ${icon} ${chalk.bold(label)}`);
+        for (const resource of grouped[difficulty]) {
+            lines.push(`  ${chalk.white(`${counter}.`)} ${resource.title}`);
+            lines.push(`     ${chalk.cyan(resource.url)}`);
+            counter++;
+        }
+        lines.push("");
+    }
+    // Check for missing difficulty levels and show placeholder
+    for (const diff of ["beginner", "intermediate", "advanced"]) {
+        if (!grouped[diff]) {
+            const icon = DIFFICULTY_ICONS[diff] ?? "";
+            const label = DIFFICULTY_LABELS[diff] ?? diff;
+            lines.push(`  ${icon} ${chalk.bold(label)}`);
+            lines.push(chalk.dim(`  (No ${diff} resources yet)`));
+            lines.push("");
+        }
+    }
+    lines.push(`  ${chalk.dim("Tip: Start with #1, then build a")}`);
+    lines.push(`  ${chalk.dim("project before moving to intermediate.")}`);
+    lines.push("");
+    console.log(box(lines.join("\n"), `Learning Path: ${displayName}`));
+    console.log("");
+});
+//# sourceMappingURL=learn.js.map

package/dist/commands/lint.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld lint — Validate a stack against team standards (.stackweldrc).
+ */
+import { Command } from "commander";
+export declare const lintCommand: Command;
+//# sourceMappingURL=lint.d.ts.map

package/dist/commands/lint.js

@@ -0,0 +1,193 @@
+/**
+ * stackweld lint — Validate a stack against team standards (.stackweldrc).
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detectStack, lintStack, loadStandards } from "@stackweld/core";
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { box, formatJson, gradientHeader } from "../ui/format.js";
+function buildStackFromDetected(detected) {
+    return {
+        name: "detected",
+        profile: "standard",
+        technologies: detected.technologies.map((t) => ({ technologyId: t.id })),
+    };
+}
+export const lintCommand = new Command("lint")
+    .description("Validate a stack against team standards (.stackweldrc)")
+    .option("-c, --config <path>", "Path to standards config file")
+    .option("-s, --stack <id>", "Lint a saved stack by ID")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    // ── Load standards ──
+    const configPath = opts.config
+        ? path.resolve(opts.config)
+        : path.resolve(process.cwd(), ".stackweldrc");
+    let standards = null;
+    if (opts.config) {
+        // Explicit config path
+        if (!fs.existsSync(configPath)) {
+            console.error(chalk.red(`\u2716 Config file not found: ${configPath}`));
+            process.exit(1);
+        }
+        standards = loadStandards(path.dirname(configPath));
+        if (!standards) {
+            // Try reading directly if the dirname resolution didn't work
+            try {
+                const content = fs.readFileSync(configPath, "utf-8");
+                standards = JSON.parse(content);
+            }
+            catch {
+                console.error(chalk.red(`\u2716 Could not parse config: ${configPath}`));
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        standards = loadStandards(process.cwd());
+    }
+    if (!standards) {
+        console.error(chalk.red("\u2716 No .stackweldrc found in current directory."));
+        console.error(chalk.dim("  Create one or use --config <path>"));
+        process.exit(1);
+    }
+    // ── Resolve stack ──
+    let stackLike;
+    if (opts.stack) {
+        const engine = getStackEngine();
+        const saved = engine.get(opts.stack);
+        if (!saved) {
+            console.error(chalk.red(`\u2716 Stack "${opts.stack}" not found.`));
+            console.error(chalk.dim("  Run: stackweld list"));
+            process.exit(1);
+        }
+        stackLike = saved;
+    }
+    else {
+        // Detect from current directory
+        const detected = detectStack(process.cwd());
+        if (detected.technologies.length === 0) {
+            console.error(chalk.red("\u2716 Could not detect any technologies in the current directory."));
+            console.error(chalk.dim("  Use --stack <id> to lint a saved stack instead."));
+            process.exit(1);
+        }
+        stackLike = buildStackFromDetected(detected);
+    }
+    // ── Run lint ──
+    // Cast to StackDefinition shape for the linter
+    const result = lintStack(stackLike, standards);
+    if (opts.json) {
+        console.log(formatJson({ standards, result }));
+        return;
+    }
+    // ── Format output ──
+    const teamName = standards.team || "Team Standards";
+    const lines = [];
+    lines.push("");
+    let passCount = 0;
+    let failCount = 0;
+    // Required technologies
+    if (standards.requiredTechnologies) {
+        const techIds = new Set(stackLike.technologies.map((t) => t.technologyId));
+        for (const req of standards.requiredTechnologies) {
+            if (techIds.has(req)) {
+                lines.push(`  ${chalk.green("\u2713")} Required: ${req}`);
+                passCount++;
+            }
+            else {
+                lines.push(`  ${chalk.red("\u2717")} Required: ${req} ${chalk.red("missing")}`);
+                failCount++;
+            }
+        }
+    }
+    // Blocked technologies
+    if (standards.blockedTechnologies) {
+        const techIds = new Set(stackLike.technologies.map((t) => t.technologyId));
+        for (const blocked of standards.blockedTechnologies) {
+            if (techIds.has(blocked)) {
+                lines.push(`  ${chalk.red("\u2717")} Blocked: ${blocked} found ${chalk.red("\u2014 remove it")}`);
+                failCount++;
+            }
+            else {
+                lines.push(`  ${chalk.green("\u2713")} Blocked: ${blocked} ${chalk.dim("(not present)")}`);
+                passCount++;
+            }
+        }
+    }
+    // Min profile
+    if (standards.minProfile) {
+        const profileViolation = result.warnings.find((w) => w.rule === "minProfile");
+        if (profileViolation) {
+            lines.push(`  ${chalk.yellow("\u26A0")} Profile: ${stackLike.profile} < ${standards.minProfile}`);
+            failCount++;
+        }
+        else {
+            lines.push(`  ${chalk.green("\u2713")} Profile: ${stackLike.profile} \u2265 ${standards.minProfile}`);
+            passCount++;
+        }
+    }
+    // Require Docker
+    if (standards.requireDocker) {
+        const dockerViolation = result.violations.find((v) => v.rule === "requireDocker");
+        if (dockerViolation) {
+            lines.push(`  ${chalk.red("\u2717")} Docker required but missing`);
+            failCount++;
+        }
+        else {
+            lines.push(`  ${chalk.green("\u2713")} Docker present`);
+            passCount++;
+        }
+    }
+    // Require tests
+    if (standards.requireTests) {
+        const testWarning = result.warnings.find((w) => w.rule === "requireTests");
+        if (testWarning) {
+            lines.push(`  ${chalk.yellow("\u26A0")} No testing framework found`);
+            failCount++;
+        }
+        else {
+            lines.push(`  ${chalk.green("\u2713")} Tests present`);
+            passCount++;
+        }
+    }
+    // Require TypeScript
+    if (standards.requireTypeScript) {
+        const tsViolation = result.violations.find((v) => v.rule === "requireTypeScript");
+        if (tsViolation) {
+            lines.push(`  ${chalk.red("\u2717")} TypeScript required but missing`);
+            failCount++;
+        }
+        else {
+            lines.push(`  ${chalk.green("\u2713")} TypeScript present`);
+            passCount++;
+        }
+    }
+    // Custom rules
+    if (standards.customRules) {
+        for (const rule of standards.customRules) {
+            const violation = result.violations.find((v) => v.rule === `custom:${rule.name}`);
+            if (violation) {
+                lines.push(`  ${chalk.red("\u2717")} ${rule.message}`);
+                failCount++;
+            }
+            else {
+                lines.push(`  ${chalk.green("\u2713")} Custom: ${rule.name}`);
+                passCount++;
+            }
+        }
+    }
+    lines.push("");
+    lines.push(`  ${chalk.green(`${String(passCount)} passed`)} ${chalk.dim("\u00B7")} ` +
+        `${failCount > 0 ? chalk.red(`${String(failCount)} violation(s)`) : chalk.dim("0 violations")}`);
+    lines.push(`  Status: ${result.passed ? chalk.green.bold("PASSED") : chalk.red.bold("FAILED")}`);
+    lines.push("");
+    console.log(`\n  ${gradientHeader("Stackweld")} ${chalk.dim("/ Lint")}\n`);
+    console.log(box(lines.join("\n"), `Stack Lint: ${teamName}`));
+    console.log("");
+    if (!result.passed) {
+        process.exit(1);
+    }
+});
+//# sourceMappingURL=lint.js.map

package/dist/commands/list.d.ts

@@ -0,0 +1,6 @@
+/**
+ * stackweld list — List saved stacks.
+ */
+import { Command } from "commander";
+export declare const listCommand: Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/list.js

@@ -0,0 +1,27 @@
+/**
+ * stackweld list — List saved stacks.
+ */
+import chalk from "chalk";
+import { Command } from "commander";
+import { getStackEngine } from "../ui/context.js";
+import { emptyState, formatJson, formatStackTable } from "../ui/format.js";
+export const listCommand = new Command("list")
+    .aliases(["ls"])
+    .description("List all saved stacks")
+    .option("--json", "Output as JSON")
+    .action((opts) => {
+    const engine = getStackEngine();
+    const stacks = engine.list();
+    if (stacks.length === 0) {
+        console.log(emptyState("No stacks saved yet.", "Run `stackweld init` to create one."));
+        return;
+    }
+    if (opts.json) {
+        console.log(formatJson(stacks));
+        return;
+    }
+    console.log(chalk.bold(`\n  ${stacks.length} stack(s)\n`));
+    console.log(formatStackTable(stacks));
+    console.log("");
+});
+//# sourceMappingURL=list.js.map

package/dist/commands/logs.d.ts

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