airgen-cli 0.1.0

package/dist/commands/reports.js

@@ -0,0 +1,114 @@
+import { output, printTable, isJsonMode, truncate } from "../output.js";
+export function registerReportCommands(program, client) {
+    const cmd = program.command("reports").alias("report").description("Project reports");
+    cmd
+        .command("stats")
+        .description("Project statistics overview")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const [reqs, links, docs, diagrams, baselines] = await Promise.all([
+            client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: "1" }),
+            client.get(`/trace-links/${tenant}/${project}`),
+            client.get(`/documents/${tenant}/${project}`),
+            client.get(`/architecture/diagrams/${tenant}/${project}`),
+            client.get(`/baselines/${tenant}/${project}`),
+        ]);
+        const stats = {
+            requirements: reqs.meta?.totalItems ?? 0,
+            traceLinks: (links.links ?? []).length,
+            documents: (docs.documents ?? []).length,
+            diagrams: (diagrams.diagrams ?? []).length,
+            baselines: (baselines.baselines ?? []).length,
+        };
+        if (isJsonMode()) {
+            output(stats);
+        }
+        else {
+            printTable(["Metric", "Count"], Object.entries(stats).map(([k, v]) => [k, String(v)]));
+        }
+    });
+    cmd
+        .command("quality")
+        .description("Quality score summary")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("-l, --limit <n>", "Max requirements to fetch", "100")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: opts.limit });
+        const reqs = data.data ?? [];
+        const scored = reqs.filter(r => r.qaScore != null);
+        const avg = scored.length > 0
+            ? scored.reduce((sum, r) => sum + (r.qaScore ?? 0), 0) / scored.length
+            : 0;
+        const below50 = scored.filter(r => (r.qaScore ?? 0) < 50);
+        if (isJsonMode()) {
+            output({ total: reqs.length, scored: scored.length, averageScore: Math.round(avg), belowThreshold: below50.length });
+        }
+        else {
+            console.log(`Total requirements: ${reqs.length}`);
+            console.log(`Scored: ${scored.length}`);
+            console.log(`Average QA score: ${Math.round(avg)}/100`);
+            console.log(`Below 50: ${below50.length}`);
+            if (below50.length > 0) {
+                console.log("\nLowest scoring:");
+                printTable(["Ref", "Score", "Text"], below50
+                    .sort((a, b) => (a.qaScore ?? 0) - (b.qaScore ?? 0))
+                    .slice(0, 10)
+                    .map(r => [r.ref ?? "?", String(r.qaScore ?? 0), truncate(r.text ?? "", 60)]));
+            }
+        }
+    });
+    cmd
+        .command("compliance")
+        .description("Compliance status summary")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("-l, --limit <n>", "Max requirements to fetch", "100")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: opts.limit });
+        const reqs = data.data ?? [];
+        const counts = {};
+        for (const r of reqs) {
+            const status = r.complianceStatus || "Unset";
+            counts[status] = (counts[status] ?? 0) + 1;
+        }
+        if (isJsonMode()) {
+            output(counts);
+        }
+        else {
+            printTable(["Status", "Count"], Object.entries(counts).map(([k, v]) => [k, String(v)]));
+        }
+    });
+    cmd
+        .command("orphans")
+        .description("Find requirements with no trace links")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("-l, --limit <n>", "Max requirements to fetch", "100")
+        .action(async (tenant, project, opts) => {
+        const [reqData, linkData] = await Promise.all([
+            client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: opts.limit }),
+            client.get(`/trace-links/${tenant}/${project}`),
+        ]);
+        const reqs = reqData.data ?? [];
+        const links = linkData.links ?? [];
+        const linked = new Set();
+        for (const l of links) {
+            if (l.sourceRequirementId)
+                linked.add(l.sourceRequirementId);
+            if (l.targetRequirementId)
+                linked.add(l.targetRequirementId);
+        }
+        const orphans = reqs.filter(r => r.id && !linked.has(r.id));
+        if (isJsonMode()) {
+            output(orphans);
+        }
+        else {
+            console.log(`Orphan requirements (no trace links): ${orphans.length}/${reqs.length}\n`);
+            if (orphans.length > 0) {
+                printTable(["Ref", "Text"], orphans.slice(0, 30).map(r => [r.ref ?? "?", truncate(r.text ?? "", 70)]));
+            }
+        }
+    });
+}

package/dist/commands/requirements.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { AirgenClient } from "../client.js";
+export declare function registerRequirementCommands(program: Command, client: AirgenClient): void;

package/dist/commands/requirements.js

@@ -0,0 +1,231 @@
+import { output, printTable, isJsonMode, truncate } from "../output.js";
+export function registerRequirementCommands(program, client) {
+    const cmd = program.command("requirements").alias("reqs").description("Manage requirements");
+    cmd
+        .command("list")
+        .description("List requirements with pagination")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("-p, --page <n>", "Page number", "1")
+        .option("-l, --limit <n>", "Items per page", "25")
+        .option("--sort <field>", "Sort by: ref, createdAt, qaScore")
+        .option("--order <dir>", "Sort order: asc, desc")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/requirements/${tenant}/${project}`, { page: opts.page, limit: opts.limit, sortBy: opts.sort, sortOrder: opts.order });
+        const reqs = data.data ?? [];
+        const meta = data.meta;
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            if (reqs.length === 0) {
+                console.log("No requirements found.");
+                return;
+            }
+            console.log(`Requirements (${meta?.totalItems ?? reqs.length} total, page ${meta?.currentPage ?? 1}/${meta?.totalPages ?? 1})\n`);
+            printTable(["Ref", "Text", "Pattern", "QA", "Tags"], reqs.map(r => [
+                r.ref ?? "?",
+                truncate(r.text ?? "", 60),
+                r.pattern ?? "",
+                r.qaScore != null ? String(r.qaScore) : "-",
+                (r.tags ?? []).join(", "),
+            ]));
+        }
+    });
+    cmd
+        .command("get")
+        .description("Get full details of a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<ref>", "Requirement reference (e.g. REQ-001)")
+        .action(async (tenant, project, ref) => {
+        const data = await client.get(`/requirements/${tenant}/${project}/${ref}`);
+        const r = data.record ?? data;
+        if (isJsonMode()) {
+            output(r);
+        }
+        else {
+            const lines = [
+                `${r.ref ?? ref}${r.qaScore != null ? ` (QA: ${r.qaScore}/100)` : ""}`,
+                "",
+                r.title ? `Title: ${r.title}` : null,
+                r.text ? `Text: ${r.text}` : null,
+                r.pattern ? `Pattern: ${r.pattern}` : null,
+                r.verification ? `Verification: ${r.verification}` : null,
+                r.rationale ? `Rationale: ${r.rationale}` : null,
+                r.complianceStatus ? `Compliance: ${r.complianceStatus}` : null,
+                r.documentSlug ? `Document: ${r.documentSlug}${r.sectionId ? ` / ${r.sectionId}` : ""}` : null,
+                r.tags?.length ? `Tags: ${r.tags.join(", ")}` : null,
+                r.id ? `ID: ${r.id}` : null,
+            ].filter(Boolean);
+            console.log(lines.join("\n"));
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a new requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--text <text>", "Requirement text")
+        .option("--pattern <p>", "Pattern: ubiquitous, event, state, unwanted, optional")
+        .option("--verification <v>", "Verification: Test, Analysis, Inspection, Demonstration")
+        .option("--document <slug>", "Document slug")
+        .option("--section <id>", "Section ID")
+        .option("--tags <tags>", "Comma-separated tags")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/requirements", {
+            tenant,
+            projectKey,
+            text: opts.text,
+            pattern: opts.pattern,
+            verification: opts.verification,
+            documentSlug: opts.document,
+            sectionId: opts.section,
+            tags: opts.tags?.split(",").map(t => t.trim()),
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Requirement created.");
+            output(data);
+        }
+    });
+    cmd
+        .command("update")
+        .description("Update a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Requirement ID")
+        .option("--text <text>", "Requirement text")
+        .option("--pattern <p>", "Pattern")
+        .option("--verification <v>", "Verification method")
+        .option("--rationale <r>", "Rationale")
+        .option("--compliance <status>", "Compliance status")
+        .option("--section <id>", "Section ID")
+        .option("--tags <tags>", "Comma-separated tags")
+        .action(async (tenant, project, id, opts) => {
+        const body = {};
+        if (opts.text)
+            body.text = opts.text;
+        if (opts.pattern)
+            body.pattern = opts.pattern;
+        if (opts.verification)
+            body.verification = opts.verification;
+        if (opts.rationale)
+            body.rationale = opts.rationale;
+        if (opts.compliance)
+            body.complianceStatus = opts.compliance;
+        if (opts.section)
+            body.sectionId = opts.section;
+        if (opts.tags)
+            body.tags = opts.tags.split(",").map(t => t.trim());
+        await client.patch(`/requirements/${tenant}/${project}/${id}`, body);
+        if (isJsonMode()) {
+            output({ ok: true });
+        }
+        else {
+            console.log("Requirement updated.");
+        }
+    });
+    cmd
+        .command("delete")
+        .description("Soft-delete a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Requirement ID")
+        .action(async (tenant, project, id) => {
+        await client.delete(`/requirements/${tenant}/${project}/${id}`);
+        console.log("Requirement deleted.");
+    });
+    cmd
+        .command("history")
+        .description("Get version history of a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Requirement ID")
+        .action(async (tenant, project, id) => {
+        const data = await client.get(`/requirements/${tenant}/${project}/${id}/history`);
+        output(data);
+    });
+    cmd
+        .command("search")
+        .description("Search requirements (semantic, similar, duplicates)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .requiredOption("-q, --query <text>", "Search query")
+        .option("--mode <m>", "Mode: semantic, similar, duplicates", "semantic")
+        .option("-l, --limit <n>", "Max results")
+        .option("--min-similarity <n>", "Minimum similarity score")
+        .action(async (tenant, project, opts) => {
+        if (opts.mode === "semantic") {
+            const data = await client.post("/requirements/search/semantic", {
+                tenant,
+                project,
+                query: opts.query,
+                limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+                minSimilarity: opts.minSimilarity ? parseFloat(opts.minSimilarity) : undefined,
+            });
+            output(data);
+        }
+        else {
+            // similar/duplicates modes need a requirementId
+            console.error("Similar/duplicates modes require --requirement-id (not yet implemented in CLI).");
+        }
+    });
+    cmd
+        .command("filter")
+        .description("Advanced filtering with multiple criteria")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("--tags <tags>", "Comma-separated tags")
+        .option("--pattern <p>", "Pattern filter")
+        .option("--verification <v>", "Verification filter")
+        .option("--compliance <status>", "Compliance status filter")
+        .option("--qa-min <n>", "Min QA score")
+        .option("--qa-max <n>", "Max QA score")
+        .option("--document <slug>", "Document slug")
+        .option("--section <id>", "Section ID")
+        .option("--contains <text>", "Text contains")
+        .option("-p, --page <n>", "Page number", "1")
+        .option("-l, --limit <n>", "Items per page", "50")
+        .action(async (tenant, project, opts) => {
+        // Fetch requirements and filter client-side (matching MCP approach)
+        const data = await client.get(`/requirements/${tenant}/${project}`, { page: opts.page, limit: opts.limit });
+        let reqs = data.data ?? [];
+        if (opts.tags) {
+            const filterTags = opts.tags.split(",").map(t => t.trim().toLowerCase());
+            reqs = reqs.filter(r => r.tags?.some(t => filterTags.includes(t.toLowerCase())));
+        }
+        if (opts.pattern)
+            reqs = reqs.filter(r => r.pattern === opts.pattern);
+        if (opts.verification)
+            reqs = reqs.filter(r => r.verification === opts.verification);
+        if (opts.compliance)
+            reqs = reqs.filter(r => r.complianceStatus === opts.compliance);
+        if (opts.qaMin)
+            reqs = reqs.filter(r => (r.qaScore ?? 0) >= parseInt(opts.qaMin, 10));
+        if (opts.qaMax)
+            reqs = reqs.filter(r => (r.qaScore ?? 0) <= parseInt(opts.qaMax, 10));
+        if (opts.document)
+            reqs = reqs.filter(r => r.documentSlug === opts.document);
+        if (opts.section)
+            reqs = reqs.filter(r => r.sectionId === opts.section);
+        if (opts.contains) {
+            const term = opts.contains.toLowerCase();
+            reqs = reqs.filter(r => r.text?.toLowerCase().includes(term));
+        }
+        if (isJsonMode()) {
+            output(reqs);
+        }
+        else {
+            console.log(`Filtered: ${reqs.length} requirements\n`);
+            printTable(["Ref", "Text", "Pattern", "QA"], reqs.map(r => [
+                r.ref ?? "?",
+                truncate(r.text ?? "", 60),
+                r.pattern ?? "",
+                r.qaScore != null ? String(r.qaScore) : "-",
+            ]));
+        }
+    });
+}

package/dist/commands/tenants.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { AirgenClient } from "../client.js";
+export declare function registerTenantCommands(program: Command, client: AirgenClient): void;

package/dist/commands/tenants.js

@@ -0,0 +1,17 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerTenantCommands(program, client) {
+    const cmd = program.command("tenants").description("Manage tenants");
+    cmd
+        .command("list")
+        .description("List all tenants you have access to")
+        .action(async () => {
+        const data = await client.get("/tenants");
+        const tenants = data.tenants ?? [];
+        if (isJsonMode()) {
+            output(tenants);
+        }
+        else {
+            printTable(["Slug", "Name", "Created"], tenants.map(t => [t.slug, t.name ?? t.slug, t.createdAt ?? ""]));
+        }
+    });
+}

package/dist/commands/traceability.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { AirgenClient } from "../client.js";
+export declare function registerTraceabilityCommands(program: Command, client: AirgenClient): void;

package/dist/commands/traceability.js

@@ -0,0 +1,106 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerTraceabilityCommands(program, client) {
+    const cmd = program.command("traces").alias("trace").description("Traceability links");
+    cmd
+        .command("list")
+        .description("List trace links in a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("--requirement <id>", "Filter by requirement ID")
+        .action(async (tenant, project, opts) => {
+        const path = opts.requirement
+            ? `/trace-links/${tenant}/${project}/${opts.requirement}`
+            : `/trace-links/${tenant}/${project}`;
+        const data = await client.get(path);
+        const links = data.links ?? [];
+        if (isJsonMode()) {
+            output(links);
+        }
+        else {
+            printTable(["ID", "Source", "Target", "Type", "Description"], links.map(l => [
+                l.id,
+                l.sourceRef ?? l.sourceRequirementId ?? "",
+                l.targetRef ?? l.targetRequirementId ?? "",
+                l.linkType ?? "",
+                l.description ?? "",
+            ]));
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a trace link between requirements")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--source <id>", "Source requirement ID")
+        .requiredOption("--target <id>", "Target requirement ID")
+        .requiredOption("--type <type>", "Link type: satisfies, derives, verifies, implements, refines, conflicts")
+        .option("--description <desc>", "Description")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/trace-links", {
+            tenant,
+            projectKey,
+            sourceRequirementId: opts.source,
+            targetRequirementId: opts.target,
+            linkType: opts.type,
+            description: opts.description,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Trace link created.");
+        }
+    });
+    cmd
+        .command("delete")
+        .description("Delete a trace link")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<link-id>", "Link ID")
+        .action(async (tenant, project, linkId) => {
+        await client.delete(`/trace-links/${tenant}/${project}/${linkId}`);
+        console.log("Trace link deleted.");
+    });
+    // Linksets
+    const linksets = cmd.command("linksets").description("Document linksets");
+    linksets
+        .command("list")
+        .description("List document linksets")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/linksets/${tenant}/${project}`);
+        output(data);
+    });
+    linksets
+        .command("create")
+        .description("Create a document linkset")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .requiredOption("--source <slug>", "Source document slug")
+        .requiredOption("--target <slug>", "Target document slug")
+        .option("--link-type <type>", "Default link type")
+        .action(async (tenant, project, opts) => {
+        const data = await client.post(`/linksets/${tenant}/${project}`, {
+            sourceDocumentSlug: opts.source,
+            targetDocumentSlug: opts.target,
+            defaultLinkType: opts.linkType,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Linkset created.");
+        }
+    });
+    linksets
+        .command("delete")
+        .description("Delete a linkset")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<linkset-id>", "Linkset ID")
+        .action(async (tenant, project, linksetId) => {
+        await client.delete(`/linksets/${tenant}/${project}/${linksetId}`);
+        console.log("Linkset deleted.");
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI configuration — loads from env vars or ~/.airgenrc JSON file.
+ */
+export interface CliConfig {
+    apiUrl: string;
+    email: string;
+    password: string;
+}
+export declare function loadConfig(): CliConfig;

package/dist/config.js

@@ -0,0 +1,30 @@
+/**
+ * CLI configuration — loads from env vars or ~/.airgenrc JSON file.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+function loadRcFile() {
+    try {
+        const raw = readFileSync(join(homedir(), ".airgenrc"), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function loadConfig() {
+    const rc = loadRcFile();
+    const apiUrl = process.env.AIRGEN_API_URL ?? rc.apiUrl;
+    const email = process.env.AIRGEN_EMAIL ?? rc.email;
+    const password = process.env.AIRGEN_PASSWORD ?? rc.password;
+    if (!apiUrl) {
+        console.error("Missing AIRGEN_API_URL. Set it via environment variable or ~/.airgenrc");
+        process.exit(1);
+    }
+    if (!email || !password) {
+        console.error("Missing AIRGEN_EMAIL / AIRGEN_PASSWORD. Set via environment or ~/.airgenrc");
+        process.exit(1);
+    }
+    return { apiUrl, email, password };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { AirgenClient } from "./client.js";
+import { loadConfig } from "./config.js";
+import { setJsonMode } from "./output.js";
+import { registerTenantCommands } from "./commands/tenants.js";
+import { registerProjectCommands } from "./commands/projects.js";
+import { registerRequirementCommands } from "./commands/requirements.js";
+import { registerDocumentCommands } from "./commands/documents.js";
+import { registerDiagramCommands } from "./commands/diagrams.js";
+import { registerTraceabilityCommands } from "./commands/traceability.js";
+import { registerBaselineCommands } from "./commands/baselines.js";
+import { registerQualityCommands } from "./commands/quality.js";
+import { registerAiCommands } from "./commands/ai.js";
+import { registerReportCommands } from "./commands/reports.js";
+import { registerImportExportCommands } from "./commands/import-export.js";
+import { registerActivityCommands } from "./commands/activity.js";
+import { registerImplementationCommands } from "./commands/implementation.js";
+const program = new Command();
+// Lazy-init: only create client when a command actually runs
+let client = null;
+function getClient() {
+    if (!client) {
+        const config = loadConfig();
+        client = new AirgenClient(config);
+    }
+    return client;
+}
+// Proxy that defers client creation — commands receive this and call methods lazily
+const clientProxy = new Proxy({}, {
+    get(_target, prop) {
+        const c = getClient();
+        const val = c[prop];
+        if (typeof val === "function")
+            return val.bind(c);
+        return val;
+    },
+});
+program
+    .name("airgen")
+    .description("AIRGen CLI — requirements engineering from the command line")
+    .version("0.1.0")
+    .option("--json", "Output as JSON")
+    .hook("preAction", (_thisCommand, actionCommand) => {
+    let cmd = actionCommand;
+    while (cmd) {
+        if (cmd.opts().json) {
+            setJsonMode(true);
+            break;
+        }
+        cmd = cmd.parent;
+    }
+});
+registerTenantCommands(program, clientProxy);
+registerProjectCommands(program, clientProxy);
+registerRequirementCommands(program, clientProxy);
+registerDocumentCommands(program, clientProxy);
+registerDiagramCommands(program, clientProxy);
+registerTraceabilityCommands(program, clientProxy);
+registerBaselineCommands(program, clientProxy);
+registerQualityCommands(program, clientProxy);
+registerAiCommands(program, clientProxy);
+registerReportCommands(program, clientProxy);
+registerImportExportCommands(program, clientProxy);
+registerActivityCommands(program, clientProxy);
+registerImplementationCommands(program, clientProxy);
+// Handle async errors from Commander action handlers
+process.on("uncaughtException", (err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+});

package/dist/output.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Output formatting for the CLI.
+ */
+export declare function setJsonMode(enabled: boolean): void;
+export declare function isJsonMode(): boolean;
+/** Print data — as JSON if --json flag, otherwise as formatted text. */
+export declare function output(data: unknown, formatted?: string): void;
+/** Print a simple table to the terminal. */
+export declare function printTable(headers: string[], rows: string[][]): void;
+/** Print an error and exit. */
+export declare function die(msg: string): never;
+/** Truncate a string. */
+export declare function truncate(text: string, max: number): string;

package/dist/output.js

@@ -0,0 +1,46 @@
+/**
+ * Output formatting for the CLI.
+ */
+let jsonMode = false;
+export function setJsonMode(enabled) {
+    jsonMode = enabled;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+/** Print data — as JSON if --json flag, otherwise as formatted text. */
+export function output(data, formatted) {
+    if (jsonMode) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(formatted ?? JSON.stringify(data, null, 2));
+    }
+}
+/** Print a simple table to the terminal. */
+export function printTable(headers, rows) {
+    if (rows.length === 0) {
+        console.log("No results.");
+        return;
+    }
+    // Calculate column widths
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => (r[i] ?? "").length)));
+    const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
+    const sep = widths.map(w => "─".repeat(w)).join("──");
+    console.log(widths.map((w, i) => pad(headers[i], w)).join("  "));
+    console.log(sep);
+    for (const row of rows) {
+        console.log(widths.map((w, i) => pad(row[i] ?? "", w)).join("  "));
+    }
+}
+/** Print an error and exit. */
+export function die(msg) {
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+}
+/** Truncate a string. */
+export function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max - 3) + "...";
+}