airgen-cli 0.1.0

package/dist/commands/diagrams.js

@@ -0,0 +1,196 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerDiagramCommands(program, client) {
+    const cmd = program.command("diagrams").alias("diag").description("Architecture diagrams");
+    cmd
+        .command("list")
+        .description("List all diagrams in a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/architecture/diagrams/${tenant}/${project}`);
+        const diagrams = data.diagrams ?? [];
+        if (isJsonMode()) {
+            output(diagrams);
+        }
+        else {
+            printTable(["ID", "Name", "View", "Blocks", "Connectors"], diagrams.map(d => [
+                d.id,
+                d.name ?? "",
+                d.view ?? "",
+                String(d.blockCount ?? 0),
+                String(d.connectorCount ?? 0),
+            ]));
+        }
+    });
+    cmd
+        .command("get")
+        .description("Get full detail of a diagram (blocks + connectors)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Diagram ID")
+        .action(async (tenant, project, id) => {
+        const [blocks, connectors] = await Promise.all([
+            client.get(`/architecture/blocks/${tenant}/${project}/${id}`),
+            client.get(`/architecture/connectors/${tenant}/${project}/${id}`),
+        ]);
+        output({ blocks, connectors });
+    });
+    cmd
+        .command("create")
+        .description("Create a new diagram")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--name <name>", "Diagram name")
+        .option("--view <view>", "View type: block, internal, deployment, requirements_schema")
+        .option("--description <desc>", "Description")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/architecture/diagrams", {
+            tenant,
+            projectKey,
+            name: opts.name,
+            view: opts.view,
+            description: opts.description,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Diagram created.");
+            output(data);
+        }
+    });
+    cmd
+        .command("update")
+        .description("Update diagram properties")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Diagram ID")
+        .option("--name <name>", "Diagram name")
+        .option("--description <desc>", "Description")
+        .option("--view <view>", "View type")
+        .action(async (tenant, project, id, opts) => {
+        const body = {};
+        if (opts.name)
+            body.name = opts.name;
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.view)
+            body.view = opts.view;
+        await client.patch(`/architecture/diagrams/${tenant}/${project}/${id}`, body);
+        console.log("Diagram updated.");
+    });
+    cmd
+        .command("delete")
+        .description("Delete a diagram")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<id>", "Diagram ID")
+        .action(async (tenant, project, id) => {
+        await client.delete(`/architecture/diagrams/${tenant}/${project}/${id}`);
+        console.log("Diagram deleted.");
+    });
+    // Blocks sub-group
+    const blocks = cmd.command("blocks").description("Manage blocks in diagrams");
+    blocks
+        .command("library")
+        .description("Get all block definitions in the project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/architecture/block-library/${tenant}/${project}`);
+        output(data);
+    });
+    blocks
+        .command("create")
+        .description("Create a new block")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--diagram <id>", "Diagram ID")
+        .requiredOption("--name <name>", "Block name")
+        .requiredOption("--kind <kind>", "Kind: system, subsystem, component, actor, external, interface")
+        .option("--x <n>", "Position X", "0")
+        .option("--y <n>", "Position Y", "0")
+        .option("--width <n>", "Width")
+        .option("--height <n>", "Height")
+        .option("--stereotype <s>", "Stereotype")
+        .option("--description <desc>", "Description")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/architecture/blocks", {
+            tenant,
+            projectKey,
+            diagramId: opts.diagram,
+            name: opts.name,
+            kind: opts.kind,
+            positionX: parseInt(opts.x, 10),
+            positionY: parseInt(opts.y, 10),
+            sizeWidth: opts.width ? parseInt(opts.width, 10) : undefined,
+            sizeHeight: opts.height ? parseInt(opts.height, 10) : undefined,
+            stereotype: opts.stereotype,
+            description: opts.description,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Block created.");
+            output(data);
+        }
+    });
+    blocks
+        .command("delete")
+        .description("Delete a block from the project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<block-id>", "Block ID")
+        .action(async (tenant, project, blockId) => {
+        await client.delete(`/architecture/blocks/${tenant}/${project}/${blockId}`);
+        console.log("Block deleted.");
+    });
+    // Connectors sub-group
+    const connectors = cmd.command("connectors").alias("conn").description("Manage connectors");
+    connectors
+        .command("create")
+        .description("Create a connector between blocks")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--diagram <id>", "Diagram ID")
+        .requiredOption("--source <id>", "Source block ID")
+        .requiredOption("--target <id>", "Target block ID")
+        .requiredOption("--kind <kind>", "Kind: association, flow, dependency, composition")
+        .option("--label <text>", "Label")
+        .option("--source-port <id>", "Source port ID")
+        .option("--target-port <id>", "Target port ID")
+        .option("--line-style <style>", "Line style: straight, smoothstep, step, polyline, bezier")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/architecture/connectors", {
+            tenant,
+            projectKey,
+            diagramId: opts.diagram,
+            source: opts.source,
+            target: opts.target,
+            kind: opts.kind,
+            label: opts.label,
+            sourcePortId: opts.sourcePort,
+            targetPortId: opts.targetPort,
+            lineStyle: opts.lineStyle,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Connector created.");
+            output(data);
+        }
+    });
+    connectors
+        .command("delete")
+        .description("Delete a connector")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<connector-id>", "Connector ID")
+        .requiredOption("--diagram <id>", "Diagram ID")
+        .action(async (tenant, project, connectorId, opts) => {
+        await client.delete(`/architecture/connectors/${tenant}/${project}/${connectorId}?diagramId=${opts.diagram}`);
+        console.log("Connector deleted.");
+    });
+}

package/dist/commands/documents.d.ts

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

package/dist/commands/documents.js

@@ -0,0 +1,123 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerDocumentCommands(program, client) {
+    const cmd = program.command("documents").alias("docs").description("Manage documents");
+    cmd
+        .command("list")
+        .description("List all documents in a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/documents/${tenant}/${project}`);
+        const docs = data.documents ?? [];
+        if (isJsonMode()) {
+            output(docs);
+        }
+        else {
+            printTable(["Slug", "Name", "Kind", "Sections", "Reqs"], docs.map(d => [
+                d.slug,
+                d.name ?? d.slug,
+                d.kind ?? "",
+                String(d.sectionCount ?? 0),
+                String(d.requirementCount ?? 0),
+            ]));
+        }
+    });
+    cmd
+        .command("get")
+        .description("Get document with all sections and content")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<slug>", "Document slug")
+        .action(async (tenant, project, slug) => {
+        const data = await client.get(`/sections/${tenant}/${project}/${slug}/full`);
+        output(data);
+    });
+    cmd
+        .command("create")
+        .description("Create a new document")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--name <name>", "Document name")
+        .option("--code <code>", "Document code")
+        .option("--description <desc>", "Description")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/documents", {
+            tenant,
+            projectKey,
+            name: opts.name,
+            shortCode: opts.code,
+            description: opts.description,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Document created.");
+            output(data);
+        }
+    });
+    cmd
+        .command("delete")
+        .description("Delete a document")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<slug>", "Document slug")
+        .action(async (tenant, project, slug) => {
+        await client.delete(`/documents/${tenant}/${project}/${slug}`);
+        console.log(`Document "${slug}" deleted.`);
+    });
+    cmd
+        .command("export")
+        .description("Export document as markdown")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<slug>", "Document slug")
+        .action(async (tenant, project, slug) => {
+        const data = await client.get(`/markdown/${tenant}/${project}/${slug}/content`);
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log(data.markdown ?? data.content ?? JSON.stringify(data, null, 2));
+        }
+    });
+    // Sections sub-group
+    const sections = cmd.command("sections").alias("sec").description("Manage document sections");
+    sections
+        .command("create")
+        .description("Create a section in a document")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .argument("<document>", "Document slug")
+        .requiredOption("--title <title>", "Section title")
+        .option("--order <n>", "Order index")
+        .option("--description <desc>", "Description")
+        .option("--code <code>", "Short code")
+        .action(async (tenant, projectKey, document, opts) => {
+        const data = await client.post("/sections", {
+            tenant,
+            projectKey,
+            documentSlug: document,
+            name: opts.title,
+            order: opts.order ? parseInt(opts.order, 10) : undefined,
+            description: opts.description,
+            shortCode: opts.code,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Section created.");
+            output(data);
+        }
+    });
+    sections
+        .command("delete")
+        .description("Delete a section")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<section-id>", "Section ID")
+        .action(async (tenant, sectionId) => {
+        await client.delete(`/sections/${sectionId}`, { tenant });
+        console.log("Section deleted.");
+    });
+}

package/dist/commands/implementation.d.ts

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

package/dist/commands/implementation.js

@@ -0,0 +1,76 @@
+import { output } from "../output.js";
+export function registerImplementationCommands(program, client) {
+    const cmd = program.command("impl").description("Implementation tracking");
+    cmd
+        .command("status")
+        .description("Set implementation status on a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<requirement-id>", "Requirement ID")
+        .requiredOption("--status <s>", "Status: not_started, in_progress, implemented, verified, blocked")
+        .option("--notes <text>", "Notes")
+        .action(async (tenant, project, requirementId, opts) => {
+        // Implementation status is stored in requirement attributes
+        const data = await client.patch(`/requirements/${tenant}/${project}/${requirementId}`, {
+            attributes: {
+                implementationStatus: opts.status,
+                implementationNotes: opts.notes,
+            },
+        });
+        output(data);
+    });
+    cmd
+        .command("link")
+        .description("Link a code artifact to a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<requirement-id>", "Requirement ID")
+        .requiredOption("--type <type>", "Artifact type: file, commit, pr, issue, test, url")
+        .requiredOption("--path <path>", "Artifact path/reference")
+        .option("--label <text>", "Label")
+        .option("--line <n>", "Line number (for file type)")
+        .action(async (tenant, project, requirementId, opts) => {
+        // Fetch current requirement to get existing artifacts
+        const reqData = await client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: "500" });
+        const req = (reqData.data ?? []).find(r => r.id === requirementId);
+        if (!req) {
+            console.error(`Requirement ${requirementId} not found.`);
+            process.exit(1);
+        }
+        const attrs = req.attributes ?? {};
+        const artifacts = attrs.artifacts ?? [];
+        const newArtifact = { type: opts.type, path: opts.path };
+        if (opts.label)
+            newArtifact.label = opts.label;
+        if (opts.line)
+            newArtifact.line = parseInt(opts.line, 10);
+        artifacts.push(newArtifact);
+        await client.patch(`/requirements/${tenant}/${project}/${requirementId}`, {
+            attributes: { ...attrs, artifacts },
+        });
+        console.log("Artifact linked.");
+    });
+    cmd
+        .command("unlink")
+        .description("Remove an artifact link from a requirement")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .argument("<requirement-id>", "Requirement ID")
+        .requiredOption("--type <type>", "Artifact type")
+        .requiredOption("--path <path>", "Artifact path")
+        .action(async (tenant, project, requirementId, opts) => {
+        const reqData = await client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: "500" });
+        const req = (reqData.data ?? []).find(r => r.id === requirementId);
+        if (!req) {
+            console.error(`Requirement ${requirementId} not found.`);
+            process.exit(1);
+        }
+        const attrs = req.attributes ?? {};
+        const artifacts = attrs.artifacts ?? [];
+        const filtered = artifacts.filter(a => !(a.type === opts.type && a.path === opts.path));
+        await client.patch(`/requirements/${tenant}/${project}/${requirementId}`, {
+            attributes: { ...attrs, artifacts: filtered },
+        });
+        console.log("Artifact unlinked.");
+    });
+}

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

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

package/dist/commands/import-export.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+import { output, isJsonMode } from "../output.js";
+export function registerImportExportCommands(program, client) {
+    const imp = program.command("import").description("Import requirements");
+    imp
+        .command("requirements")
+        .description("Import requirements from CSV file (one per line)")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--file <path>", "Path to CSV file")
+        .option("--document <slug>", "Target document slug")
+        .option("--section <id>", "Target section ID")
+        .option("--tags <tags>", "Comma-separated tags to apply to all")
+        .option("--dry-run", "Preview without importing")
+        .action(async (tenant, projectKey, opts) => {
+        const content = readFileSync(opts.file, "utf-8");
+        const lines = content.split("\n").map(l => l.trim()).filter(l => l.length > 0);
+        const tags = opts.tags?.split(",").map(t => t.trim());
+        if (opts.dryRun) {
+            console.log(`Would import ${lines.length} requirements.`);
+            for (const line of lines.slice(0, 5)) {
+                console.log(`  - ${line.slice(0, 80)}`);
+            }
+            if (lines.length > 5)
+                console.log(`  ... and ${lines.length - 5} more`);
+            return;
+        }
+        let created = 0;
+        for (const text of lines) {
+            await client.post("/requirements", {
+                tenant,
+                projectKey,
+                text,
+                documentSlug: opts.document,
+                sectionId: opts.section,
+                tags,
+            });
+            created++;
+        }
+        console.log(`Imported ${created} requirements.`);
+    });
+    const exp = program.command("export").description("Export data");
+    exp
+        .command("requirements")
+        .description("Export requirements as markdown or JSON")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("--document <slug>", "Export specific document as markdown")
+        .option("--format <fmt>", "Format: json, markdown", "json")
+        .action(async (tenant, project, opts) => {
+        if (opts.document && opts.format === "markdown") {
+            const data = await client.get(`/markdown/${tenant}/${project}/${opts.document}/content`);
+            if (isJsonMode()) {
+                output(data);
+            }
+            else {
+                console.log(data.markdown ?? data.content ?? JSON.stringify(data, null, 2));
+            }
+        }
+        else {
+            // Export all as JSON
+            const data = await client.get(`/requirements/${tenant}/${project}`, { page: "1", limit: "1000" });
+            output(data);
+        }
+    });
+}

package/dist/commands/projects.d.ts

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

package/dist/commands/projects.js

@@ -0,0 +1,56 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerProjectCommands(program, client) {
+    const cmd = program.command("projects").alias("proj").description("Manage projects");
+    cmd
+        .command("list")
+        .description("List all projects in a tenant")
+        .argument("<tenant>", "Tenant slug")
+        .action(async (tenant) => {
+        const data = await client.get(`/tenants/${tenant}/projects`);
+        const projects = data.projects ?? [];
+        if (isJsonMode()) {
+            output(projects);
+        }
+        else {
+            printTable(["Slug", "Name", "Code", "Reqs", "Docs"], projects.map(p => [
+                p.slug,
+                p.name ?? p.slug,
+                p.code ?? "",
+                String(p.requirementCount ?? 0),
+                String(p.documentCount ?? 0),
+            ]));
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a new project")
+        .argument("<tenant>", "Tenant slug")
+        .requiredOption("--name <name>", "Project name")
+        .option("--key <key>", "Project key")
+        .option("--code <code>", "Project code")
+        .option("--description <desc>", "Description")
+        .action(async (tenant, opts) => {
+        const data = await client.post(`/tenants/${tenant}/projects`, {
+            name: opts.name,
+            key: opts.key,
+            code: opts.code,
+            description: opts.description,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Project created successfully.");
+            output(data);
+        }
+    });
+    cmd
+        .command("delete")
+        .description("Delete a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        await client.delete(`/tenants/${tenant}/projects/${project}`);
+        console.log(`Project "${project}" deleted.`);
+    });
+}

package/dist/commands/quality.d.ts

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

package/dist/commands/quality.js

@@ -0,0 +1,61 @@
+import { output } from "../output.js";
+export function registerQualityCommands(program, client) {
+    const cmd = program.command("quality").alias("qa").description("Requirement quality analysis");
+    cmd
+        .command("analyze")
+        .description("Analyze requirement quality (ISO 29148 + EARS)")
+        .argument("<text>", "Requirement text to analyze")
+        .option("--auto-fix", "Suggest improved text")
+        .action(async (text, opts) => {
+        if (opts.autoFix) {
+            const data = await client.post("/apply-fix", { text });
+            output(data);
+        }
+        else {
+            const data = await client.post("/qa", { text });
+            output(data);
+        }
+    });
+    cmd
+        .command("score")
+        .description("Start, check, or stop background QA scorer")
+        .argument("<action>", "Action: start, status, stop")
+        .option("--tenant <slug>", "Tenant slug (required for start)")
+        .option("--project <slug>", "Project slug (required for start)")
+        .action(async (action, opts) => {
+        if (action === "start") {
+            const data = await client.post("/workers/qa-scorer/start", {
+                tenant: opts.tenant,
+                project: opts.project,
+            });
+            output(data);
+        }
+        else if (action === "status") {
+            const data = await client.get("/workers/qa-scorer/status");
+            output(data);
+        }
+        else if (action === "stop") {
+            const data = await client.post("/workers/qa-scorer/stop", {});
+            output(data);
+        }
+        else {
+            console.error(`Unknown action "${action}". Use: start, status, stop`);
+        }
+    });
+    cmd
+        .command("draft")
+        .description("Generate candidate requirement texts from natural language")
+        .argument("<input>", "Natural language description")
+        .option("--glossary <text>", "Domain glossary")
+        .option("--constraints <text>", "Constraints")
+        .option("-n, --count <n>", "Number of candidates")
+        .action(async (input, opts) => {
+        const data = await client.post("/draft/candidates", {
+            user_input: input,
+            glossary: opts.glossary,
+            constraints: opts.constraints,
+            n: opts.count ? parseInt(opts.count, 10) : undefined,
+        });
+        output(data);
+    });
+}

package/dist/commands/reports.d.ts

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