airgen-cli 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * AIRGen HTTP API client with JWT authentication.
+ *
+ * Handles login, token caching, and automatic refresh.
+ */
+export interface ClientConfig {
+    apiUrl: string;
+    email: string;
+    password: string;
+}
+export declare class AirgenClient {
+    private config;
+    private auth;
+    private loginPromise;
+    constructor(config: ClientConfig);
+    /** The base API URL this client is configured for. */
+    get apiUrl(): string;
+    get<T = unknown>(path: string, query?: Record<string, string | number | undefined>): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    patch<T = unknown>(path: string, body?: unknown): Promise<T>;
+    delete<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /** POST multipart/form-data (for file uploads). */
+    postMultipart<T = unknown>(path: string, fields: Record<string, string>, file: {
+        fieldName?: string;
+        filename: string;
+        contentType: string;
+        data: Buffer;
+    }): Promise<T>;
+    /** Fetch binary content from an API path (e.g. document file download). */
+    fetchBinary(path: string): Promise<{
+        data: Buffer;
+        contentType: string;
+    }>;
+    /** Fetch a static file from the server root (not the /api prefix). */
+    fetchStaticFile(relativePath: string): Promise<{
+        data: Buffer;
+        contentType: string;
+    }>;
+    private request;
+    private fetch;
+    private handleResponse;
+    private ensureAuth;
+    private login;
+    private refresh;
+}
+export declare class AirgenApiError extends Error {
+    statusCode: number;
+    apiMessage: string;
+    endpoint: string;
+    constructor(statusCode: number, apiMessage: string, endpoint: string);
+}

package/dist/client.js

@@ -0,0 +1,263 @@
+/**
+ * AIRGen HTTP API client with JWT authentication.
+ *
+ * Handles login, token caching, and automatic refresh.
+ */
+export class AirgenClient {
+    config;
+    auth = {
+        accessToken: null,
+        refreshToken: null,
+        tokenExpiresAt: 0,
+    };
+    loginPromise = null;
+    constructor(config) {
+        this.config = config;
+    }
+    /** The base API URL this client is configured for. */
+    get apiUrl() {
+        return this.config.apiUrl;
+    }
+    // ── HTTP methods ──────────────────────────────────────────────
+    async get(path, query) {
+        const qs = buildQueryString(query);
+        return this.request("GET", `${path}${qs}`);
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    async delete(path, body) {
+        return this.request("DELETE", path, body);
+    }
+    /** POST multipart/form-data (for file uploads). */
+    async postMultipart(path, fields, file) {
+        await this.ensureAuth();
+        const boundary = `----AirgenMCP${Date.now()}${Math.random().toString(36).slice(2)}`;
+        const parts = [];
+        for (const [key, value] of Object.entries(fields)) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`));
+        }
+        const fieldName = file.fieldName ?? "file";
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${fieldName}"; filename="${file.filename}"\r\nContent-Type: ${file.contentType}\r\n\r\n`));
+        parts.push(file.data);
+        parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        const headers = {
+            "Content-Type": `multipart/form-data; boundary=${boundary}`,
+            "Content-Length": String(body.byteLength),
+        };
+        if (this.auth.accessToken) {
+            headers["Authorization"] = `Bearer ${this.auth.accessToken}`;
+        }
+        if (this.auth.refreshToken) {
+            headers["Cookie"] = `airgen_refresh=${this.auth.refreshToken}`;
+        }
+        const url = `${this.config.apiUrl}${path}`;
+        const res = await globalThis.fetch(url, { method: "POST", headers, body });
+        return this.handleResponse(res, path);
+    }
+    /** Fetch binary content from an API path (e.g. document file download). */
+    async fetchBinary(path) {
+        await this.ensureAuth();
+        const res = await this.fetch("GET", path);
+        if (!res.ok) {
+            const text = await res.text();
+            const msg = text || `Request failed with status ${res.status}`;
+            throw new AirgenApiError(res.status, msg, path);
+        }
+        const contentType = res.headers.get("content-type") || "application/octet-stream";
+        const buffer = Buffer.from(await res.arrayBuffer());
+        return { data: buffer, contentType };
+    }
+    /** Fetch a static file from the server root (not the /api prefix). */
+    async fetchStaticFile(relativePath) {
+        const baseUrl = this.config.apiUrl.replace(/\/api\/?$/, "");
+        const url = `${baseUrl}${relativePath}`;
+        const res = await globalThis.fetch(url);
+        if (!res.ok) {
+            throw new AirgenApiError(res.status, `Failed to fetch ${relativePath}`, relativePath);
+        }
+        const contentType = res.headers.get("content-type") || "application/octet-stream";
+        const buffer = Buffer.from(await res.arrayBuffer());
+        return { data: buffer, contentType };
+    }
+    // ── Internal ──────────────────────────────────────────────────
+    async request(method, path, body) {
+        await this.ensureAuth();
+        const res = await this.fetch(method, path, body);
+        // If 401, try refreshing once then retry
+        if (res.status === 401 && this.auth.refreshToken) {
+            await this.refresh();
+            const retry = await this.fetch(method, path, body);
+            return this.handleResponse(retry, path);
+        }
+        return this.handleResponse(res, path);
+    }
+    async fetch(method, path, body) {
+        const headers = {};
+        if (this.auth.accessToken) {
+            headers["Authorization"] = `Bearer ${this.auth.accessToken}`;
+        }
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        if (this.auth.refreshToken) {
+            headers["Cookie"] = `airgen_refresh=${this.auth.refreshToken}`;
+        }
+        const url = `${this.config.apiUrl}${path}`;
+        try {
+            return await globalThis.fetch(url, {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+            });
+        }
+        catch (err) {
+            const e = err;
+            const cause = e.cause ? ` cause=${e.cause.message ?? e.cause}` : "";
+            console.error(`[fetch error] ${method} ${url}: ${e.message}${cause}`);
+            throw new Error(`API request failed: ${method} ${path} — ${e.message}`, { cause: err });
+        }
+    }
+    async handleResponse(res, path) {
+        if (res.status === 204) {
+            return undefined;
+        }
+        const text = await res.text();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            parsed = text;
+        }
+        if (!res.ok) {
+            const msg = typeof parsed === "object" && parsed !== null && "error" in parsed
+                ? parsed.error
+                : typeof parsed === "string"
+                    ? parsed
+                    : `Request failed with status ${res.status}`;
+            throw new AirgenApiError(res.status, msg, path);
+        }
+        return parsed;
+    }
+    // ── Auth ──────────────────────────────────────────────────────
+    async ensureAuth() {
+        // Already have a valid token (with 2min buffer)
+        if (this.auth.accessToken && Date.now() < this.auth.tokenExpiresAt - 120_000) {
+            return;
+        }
+        // Token exists but is expiring — try refresh
+        if (this.auth.refreshToken) {
+            await this.refresh();
+            return;
+        }
+        // No token at all — login
+        // Deduplicate concurrent login attempts
+        if (!this.loginPromise) {
+            this.loginPromise = this.login().finally(() => {
+                this.loginPromise = null;
+            });
+        }
+        await this.loginPromise;
+    }
+    async login() {
+        const res = await globalThis.fetch(`${this.config.apiUrl}/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                email: this.config.email,
+                password: this.config.password,
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            let msg = `Login failed (${res.status})`;
+            try {
+                const json = JSON.parse(text);
+                msg = json.error ?? msg;
+            }
+            catch { /* keep default */ }
+            throw new AirgenApiError(res.status, msg, "/auth/login");
+        }
+        const data = await res.json();
+        if ("status" in data && data.status === "MFA_REQUIRED") {
+            throw new Error("AIRGen account has MFA enabled. MFA is not supported in headless MCP mode. " +
+                "Please disable MFA for the MCP service account, or use a dedicated account without MFA.");
+        }
+        if (!("token" in data)) {
+            throw new Error("Unexpected login response from AIRGen API");
+        }
+        this.auth.accessToken = data.token;
+        this.auth.tokenExpiresAt = decodeTokenExpiry(data.token);
+        this.auth.refreshToken = extractRefreshToken(res);
+    }
+    async refresh() {
+        const headers = {};
+        if (this.auth.refreshToken) {
+            headers["Cookie"] = `airgen_refresh=${this.auth.refreshToken}`;
+        }
+        const res = await globalThis.fetch(`${this.config.apiUrl}/auth/refresh`, {
+            method: "POST",
+            headers,
+        });
+        if (!res.ok) {
+            // Refresh failed — clear state and re-login
+            this.auth = { accessToken: null, refreshToken: null, tokenExpiresAt: 0 };
+            await this.login();
+            return;
+        }
+        const data = await res.json();
+        this.auth.accessToken = data.token;
+        this.auth.tokenExpiresAt = decodeTokenExpiry(data.token);
+        const newRefresh = extractRefreshToken(res);
+        if (newRefresh) {
+            this.auth.refreshToken = newRefresh;
+        }
+    }
+}
+// ── Error class ───────────────────────────────────────────────
+export class AirgenApiError extends Error {
+    statusCode;
+    apiMessage;
+    endpoint;
+    constructor(statusCode, apiMessage, endpoint) {
+        super(`AIRGen API error (${statusCode}) on ${endpoint}: ${apiMessage}`);
+        this.statusCode = statusCode;
+        this.apiMessage = apiMessage;
+        this.endpoint = endpoint;
+        this.name = "AirgenApiError";
+    }
+}
+// ── Helpers ───────────────────────────────────────────────────
+function decodeTokenExpiry(jwt) {
+    try {
+        const payload = jwt.split(".")[1];
+        const decoded = JSON.parse(Buffer.from(payload, "base64url").toString());
+        return (decoded.exp ?? 0) * 1000; // Convert seconds to ms
+    }
+    catch {
+        // If we can't decode, assume 10 minutes from now
+        return Date.now() + 10 * 60 * 1000;
+    }
+}
+function extractRefreshToken(res) {
+    const setCookie = res.headers.get("set-cookie");
+    if (!setCookie)
+        return null;
+    // Parse airgen_refresh cookie value
+    const match = setCookie.match(/airgen_refresh=([^;]+)/);
+    return match ? match[1] : null;
+}
+function buildQueryString(params) {
+    if (!params)
+        return "";
+    const entries = Object.entries(params).filter((entry) => entry[1] !== undefined);
+    if (entries.length === 0)
+        return "";
+    const qs = new URLSearchParams(entries.map(([k, v]) => [k, String(v)]));
+    return `?${qs.toString()}`;
+}

package/dist/commands/activity.d.ts

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

package/dist/commands/activity.js

@@ -0,0 +1,33 @@
+import { output, printTable, isJsonMode, truncate } from "../output.js";
+export function registerActivityCommands(program, client) {
+    const cmd = program.command("activity").description("Project activity timeline");
+    cmd
+        .command("list")
+        .description("Get activity timeline for a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .option("-l, --limit <n>", "Max entries")
+        .option("--type <type>", "Activity type filter")
+        .option("--action <action>", "Action type filter")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get("/activity", {
+            tenantSlug: tenant,
+            projectSlug: project,
+            limit: opts.limit,
+            activityTypes: opts.type,
+            actionTypes: opts.action,
+        });
+        const activities = data.activities ?? [];
+        if (isJsonMode()) {
+            output(activities);
+        }
+        else {
+            printTable(["Time", "Type", "Action", "Description"], activities.map(a => [
+                a.createdAt ?? "",
+                a.type ?? "",
+                a.action ?? "",
+                truncate(a.description ?? "", 60),
+            ]));
+        }
+    });
+}

package/dist/commands/ai.d.ts

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

package/dist/commands/ai.js

@@ -0,0 +1,86 @@
+import { output, printTable, isJsonMode, truncate } from "../output.js";
+export function registerAiCommands(program, client) {
+    const cmd = program.command("ai").description("AI generation and candidates");
+    cmd
+        .command("generate")
+        .description("Generate requirement candidates using AI")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .requiredOption("--input <text>", "Natural language input")
+        .option("--glossary <text>", "Domain glossary")
+        .option("--constraints <text>", "Constraints")
+        .option("-n, --count <n>", "Number of candidates")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/airgen/chat", {
+            tenant,
+            projectKey,
+            user_input: opts.input,
+            glossary: opts.glossary,
+            constraints: opts.constraints,
+            n: opts.count ? parseInt(opts.count, 10) : undefined,
+            mode: "generate",
+        });
+        output(data);
+    });
+    cmd
+        .command("candidates")
+        .description("List pending AI-generated candidates")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/airgen/candidates/${tenant}/${project}`);
+        const candidates = data.candidates ?? [];
+        if (isJsonMode()) {
+            output(candidates);
+        }
+        else {
+            printTable(["ID", "Text", "Status", "Created"], candidates.map(c => [
+                c.id,
+                truncate(c.text ?? "", 60),
+                c.status ?? "",
+                c.createdAt ?? "",
+            ]));
+        }
+    });
+    cmd
+        .command("accept")
+        .description("Accept a candidate and promote to requirement")
+        .argument("<candidate-id>", "Candidate ID")
+        .requiredOption("--tenant <slug>", "Tenant slug")
+        .requiredOption("--project-key <key>", "Project key")
+        .option("--pattern <p>", "Pattern")
+        .option("--verification <v>", "Verification method")
+        .option("--document <slug>", "Document slug")
+        .option("--section <id>", "Section ID")
+        .option("--tags <tags>", "Comma-separated tags")
+        .action(async (candidateId, opts) => {
+        const data = await client.post(`/airgen/candidates/${candidateId}/accept`, {
+            tenant: opts.tenant,
+            projectKey: opts.projectKey,
+            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("Candidate accepted.");
+        }
+    });
+    cmd
+        .command("reject")
+        .description("Reject a candidate")
+        .argument("<candidate-id>", "Candidate ID")
+        .requiredOption("--tenant <slug>", "Tenant slug")
+        .requiredOption("--project-key <key>", "Project key")
+        .action(async (candidateId, opts) => {
+        await client.post(`/airgen/candidates/${candidateId}/reject`, {
+            tenant: opts.tenant,
+            projectKey: opts.projectKey,
+        });
+        console.log("Candidate rejected.");
+    });
+}

package/dist/commands/baselines.d.ts

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

package/dist/commands/baselines.js

@@ -0,0 +1,55 @@
+import { output, printTable, isJsonMode } from "../output.js";
+export function registerBaselineCommands(program, client) {
+    const cmd = program.command("baselines").alias("bl").description("Baseline snapshots");
+    cmd
+        .command("list")
+        .description("List all baselines for a project")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .action(async (tenant, project) => {
+        const data = await client.get(`/baselines/${tenant}/${project}`);
+        const baselines = data.baselines ?? [];
+        if (isJsonMode()) {
+            output(baselines);
+        }
+        else {
+            printTable(["Ref", "Label", "Created", "Requirements"], baselines.map(b => [
+                b.ref ?? b.id,
+                b.label ?? "",
+                b.createdAt ?? "",
+                String(b.requirementCount ?? 0),
+            ]));
+        }
+    });
+    cmd
+        .command("create")
+        .description("Create a new baseline snapshot")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project-key>", "Project key")
+        .option("--label <label>", "Baseline label")
+        .action(async (tenant, projectKey, opts) => {
+        const data = await client.post("/baseline", {
+            tenant,
+            projectKey,
+            label: opts.label,
+        });
+        if (isJsonMode()) {
+            output(data);
+        }
+        else {
+            console.log("Baseline created.");
+            output(data);
+        }
+    });
+    cmd
+        .command("compare")
+        .description("Compare two baselines")
+        .argument("<tenant>", "Tenant slug")
+        .argument("<project>", "Project slug")
+        .requiredOption("--from <ref>", "From baseline ref")
+        .requiredOption("--to <ref>", "To baseline ref")
+        .action(async (tenant, project, opts) => {
+        const data = await client.get(`/baselines/${tenant}/${project}/compare`, { from: opts.from, to: opts.to });
+        output(data);
+    });
+}

package/dist/commands/diagrams.d.ts

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