@vertaaux/cli 0.2.0

package/dist/commands/baseline.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Baseline command for VertaaUX CLI.
+ *
+ * Manages baseline files for tracking technical debt.
+ * - Create baseline from audit results
+ * - Add individual issues to baseline (ignore)
+ * - List baseline summary
+ */
+import type { Command } from "commander";
+export interface BaselineCommandOptions {
+    path?: string;
+    fromFile?: string;
+    ignore?: string;
+    reason?: string;
+    list?: boolean;
+    base?: string;
+}
+/**
+ * Register the baseline command with the Commander program.
+ */
+export declare function registerBaselineCommand(program: Command): void;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/commands/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../../src/commands/baseline.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoIzC,MAAM,WAAW,sBAAsB;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA8H9D"}

package/dist/commands/baseline.js

@@ -0,0 +1,210 @@
+/**
+ * Baseline command for VertaaUX CLI.
+ *
+ * Manages baseline files for tracking technical debt.
+ * - Create baseline from audit results
+ * - Add individual issues to baseline (ignore)
+ * - List baseline summary
+ */
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { ExitCode } from "../utils/exit-codes.js";
+import { loadBaseline, saveBaseline, createBaseline, addToBaseline, DEFAULT_BASELINE_PATH, } from "../baseline/manager.js";
+import { generateFingerprint } from "../baseline/hash.js";
+const DEFAULT_API_BASE = "https://vertaaux.ai/v1";
+/**
+ * Get API base URL from environment.
+ */
+function getApiBase() {
+    return (process.env.VERTAAUX_API_BASE || DEFAULT_API_BASE).replace(/\/$/, "");
+}
+/**
+ * Get API key from environment.
+ */
+function getApiKey() {
+    const key = process.env.VERTAAUX_API_KEY;
+    if (!key) {
+        throw new Error("VERTAAUX_API_KEY is required");
+    }
+    return key;
+}
+/**
+ * Fetch audit results from API.
+ */
+async function fetchAudit(jobId) {
+    const base = getApiBase();
+    const url = `${base}/audit/${jobId}`;
+    const res = await fetch(url, {
+        method: "GET",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": getApiKey(),
+        },
+    });
+    if (!res.ok) {
+        let detail = res.statusText;
+        try {
+            const data = await res.json();
+            detail = data.error || data.message || detail;
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(`HTTP ${res.status}: ${detail}`);
+    }
+    return (await res.json());
+}
+/**
+ * Normalize issues from various API response formats.
+ */
+function normalizeIssues(issues) {
+    if (Array.isArray(issues))
+        return issues;
+    if (issues && typeof issues === "object") {
+        const values = Object.values(issues);
+        return values.flatMap((value) => Array.isArray(value) ? value : []);
+    }
+    return [];
+}
+/**
+ * Find an issue by ID from audit results.
+ */
+function findIssueById(issues, id) {
+    // Try exact match first
+    const exact = issues.find((issue) => issue.id === id || issue.ruleId === id || issue.rule_id === id);
+    if (exact)
+        return exact;
+    // Try fingerprint match
+    for (const issue of issues) {
+        const fp = generateFingerprint(issue);
+        if (fp === id || fp.startsWith(id)) {
+            return issue;
+        }
+    }
+    return undefined;
+}
+/**
+ * Format baseline summary for display.
+ */
+function formatBaselineSummary(baseline) {
+    const lines = [];
+    lines.push(`Baseline: ${baseline.url}`);
+    lines.push(`Issues: ${baseline.issues.length}`);
+    lines.push(`Created: ${baseline.created}`);
+    lines.push(`Updated: ${baseline.updated}`);
+    // Count by severity
+    const bySeverity = {};
+    for (const issue of baseline.issues) {
+        const sev = issue.severity || "unknown";
+        bySeverity[sev] = (bySeverity[sev] || 0) + 1;
+    }
+    const severityCounts = Object.entries(bySeverity)
+        .map(([sev, count]) => `${count} ${sev}`)
+        .join(", ");
+    if (severityCounts) {
+        lines.push(`Breakdown: ${severityCounts}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Register the baseline command with the Commander program.
+ */
+export function registerBaselineCommand(program) {
+    program
+        .command("baseline [job-id]")
+        .description("Create or update baseline from audit results")
+        .option("--path <path>", "Baseline file path", DEFAULT_BASELINE_PATH)
+        .option("--from-file <file>", "Create baseline from JSON audit file")
+        .option("--ignore <id>", "Add single issue to existing baseline by ID")
+        .option("--reason <text>", "Reason for baseline/ignore (optional)")
+        .option("--list", "Show baselined issues count and last update")
+        .action(async (jobIdArg, cmdOptions) => {
+        try {
+            const baselinePath = cmdOptions.path || DEFAULT_BASELINE_PATH;
+            // Handle --list: show baseline summary
+            if (cmdOptions.list) {
+                const baseline = await loadBaseline(baselinePath);
+                if (!baseline) {
+                    console.error("No baseline found.");
+                    console.error(`Create one with: vertaa baseline <job-id> --path ${baselinePath}`);
+                    return;
+                }
+                console.error(formatBaselineSummary(baseline));
+                return;
+            }
+            // Handle --ignore: add single issue to baseline
+            if (cmdOptions.ignore) {
+                const issueId = cmdOptions.ignore;
+                let baseline = await loadBaseline(baselinePath);
+                if (!baseline) {
+                    console.error("No baseline found. Create one first with: vertaa baseline <job-id>");
+                    process.exit(ExitCode.ERROR);
+                }
+                // Need to find the issue to add it properly
+                // If we have a job ID, fetch the audit; otherwise use a minimal issue
+                let issue;
+                if (jobIdArg) {
+                    const audit = await fetchAudit(jobIdArg);
+                    const issues = normalizeIssues(audit.issues);
+                    const found = findIssueById(issues, issueId);
+                    if (!found) {
+                        console.error(`Issue "${issueId}" not found in job ${jobIdArg}`);
+                        process.exit(ExitCode.ERROR);
+                    }
+                    issue = found;
+                }
+                else {
+                    // Create minimal issue from ID only
+                    issue = { id: issueId, description: `Ignored: ${issueId}` };
+                }
+                baseline = addToBaseline(baseline, issue, cmdOptions.reason);
+                await saveBaseline(baseline, baselinePath);
+                console.error(`Added issue ${issueId} to baseline`);
+                if (cmdOptions.reason) {
+                    console.error(`Reason: ${cmdOptions.reason}`);
+                }
+                return;
+            }
+            // Handle --from-file: create baseline from JSON file
+            if (cmdOptions.fromFile) {
+                const filePath = cmdOptions.fromFile;
+                if (!existsSync(filePath)) {
+                    console.error(`File not found: ${filePath}`);
+                    process.exit(ExitCode.ERROR);
+                }
+                const content = await readFile(filePath, "utf-8");
+                const data = JSON.parse(content);
+                const issues = normalizeIssues(data.issues);
+                const url = data.url || "unknown";
+                const baseline = createBaseline(issues, url);
+                await saveBaseline(baseline, baselinePath);
+                console.error(`Baseline created with ${issues.length} issues`);
+                console.error(`Saved to: ${baselinePath}`);
+                return;
+            }
+            // Handle job-id: create baseline from API audit
+            if (!jobIdArg) {
+                console.error("Provide job ID or use --from-file or --list");
+                console.error("Usage: vertaa baseline <job-id>");
+                console.error("       vertaa baseline --from-file <audit.json>");
+                console.error("       vertaa baseline --list");
+                process.exit(ExitCode.ERROR);
+            }
+            const audit = await fetchAudit(jobIdArg);
+            if (audit.status !== "completed") {
+                console.error(`Audit ${jobIdArg} is not completed (status: ${audit.status})`);
+                process.exit(ExitCode.ERROR);
+            }
+            const issues = normalizeIssues(audit.issues);
+            const url = audit.url || "unknown";
+            const baseline = createBaseline(issues, url);
+            await saveBaseline(baseline, baselinePath);
+            console.error(`Baseline created with ${issues.length} issues`);
+            console.error(`Saved to: ${baselinePath}`);
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}

package/dist/commands/comment.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Comment command for VertaaUX CLI.
+ *
+ * Generates markdown for PR comments from audit results.
+ * Supports posting to GitHub and GitLab via their APIs.
+ * Uses sticky comment semantics to update existing comments.
+ */
+import { Command } from "commander";
+/**
+ * Register the comment command with the Commander program.
+ */
+export declare function registerCommentCommand(program: Command): void;
+export { formatMarkdownComment as generateComment } from "../output/markdown.js";
+//# sourceMappingURL=comment.d.ts.map

package/dist/commands/comment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment.d.ts","sourceRoot":"","sources":["../../src/commands/comment.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgZpC;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6F7D;AAGD,OAAO,EAAE,qBAAqB,IAAI,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/commands/comment.js

@@ -0,0 +1,363 @@
+/**
+ * Comment command for VertaaUX CLI.
+ *
+ * Generates markdown for PR comments from audit results.
+ * Supports posting to GitHub and GitLab via their APIs.
+ * Uses sticky comment semantics to update existing comments.
+ */
+import fs from "fs";
+import path from "path";
+import { loadBaseline } from "../baseline/manager.js";
+import { ExitCode } from "../utils/exit-codes.js";
+import { formatMarkdownComment, categorizeIssuesForComment, } from "../output/markdown.js";
+import { createEnvelope, writeJsonOutput, writeOutput } from "../output/envelope.js";
+import { resolveCommandFormat } from "../output/formats.js";
+import { postOrUpdateGitHubComment, parseRepository, extractPRNumber, } from "../ci/github-api.js";
+import { postOrUpdateGitLabNote, getGitLabConfig, extractMRIid, } from "../ci/gitlab-api.js";
+/**
+ * Default path for latest audit results.
+ */
+const LATEST_AUDIT_PATH = ".vertaaux/latest-audit.json";
+/**
+ * Hidden header identifier for sticky comments.
+ */
+const COMMENT_HEADER = "vertaaux-audit";
+/**
+ * Normalize issues from various API response formats.
+ */
+function normalizeIssues(issues) {
+    if (Array.isArray(issues))
+        return issues;
+    if (issues && typeof issues === "object") {
+        const values = Object.values(issues);
+        return values.flatMap((value) => Array.isArray(value) ? value : []);
+    }
+    return [];
+}
+/**
+ * Detect CI context from environment variables.
+ *
+ * Checks for GitHub Actions and GitLab CI environments.
+ * Returns null if not in a recognized CI environment.
+ */
+function detectCIContext() {
+    // GitHub Actions
+    if (process.env.GITHUB_ACTIONS) {
+        const token = process.env.GITHUB_TOKEN;
+        if (!token)
+            return null;
+        const repo = process.env.GITHUB_REPOSITORY; // 'owner/repo'
+        const parsed = repo ? parseRepository(repo) : null;
+        const prNumber = extractPRNumber();
+        if (!parsed || !prNumber)
+            return null;
+        return {
+            platform: "github",
+            token,
+            repo: parsed.repo,
+            owner: parsed.owner,
+            prNumber,
+        };
+    }
+    // GitLab CI
+    if (process.env.GITLAB_CI) {
+        const config = getGitLabConfig();
+        if (!config)
+            return null;
+        const mrIid = extractMRIid();
+        if (!mrIid)
+            return null;
+        return {
+            platform: "gitlab",
+            token: config.token,
+            apiUrl: config.apiUrl,
+            projectId: config.projectId,
+            mrIid,
+        };
+    }
+    return null;
+}
+/**
+ * Post comment to GitHub PR.
+ */
+async function postToGitHub(context, markdown) {
+    if (!context.owner || !context.repo || !context.prNumber) {
+        throw new Error("Missing GitHub context (owner, repo, or PR number)");
+    }
+    const result = await postOrUpdateGitHubComment({
+        token: context.token,
+        owner: context.owner,
+        repo: context.repo,
+        prNumber: context.prNumber,
+        body: markdown,
+        header: COMMENT_HEADER,
+    });
+    return { url: result.html_url };
+}
+/**
+ * Post note to GitLab MR.
+ */
+async function postToGitLab(context, markdown) {
+    if (!context.apiUrl || !context.projectId || !context.mrIid) {
+        throw new Error("Missing GitLab context (apiUrl, projectId, or mrIid)");
+    }
+    const result = await postOrUpdateGitLabNote({
+        token: context.token,
+        apiUrl: context.apiUrl,
+        projectId: context.projectId,
+        mrIid: context.mrIid,
+        body: markdown,
+        header: COMMENT_HEADER,
+    });
+    return { url: result.web_url };
+}
+/**
+ * Post comment to the appropriate CI platform.
+ */
+async function postComment(context, markdown) {
+    if (context.platform === "github") {
+        return postToGitHub(context, markdown);
+    }
+    else if (context.platform === "gitlab") {
+        return postToGitLab(context, markdown);
+    }
+    throw new Error(`Unsupported CI platform: ${context.platform}`);
+}
+/**
+ * Handle the comment command.
+ */
+async function handleComment(options) {
+    let auditResult;
+    // Load audit results
+    if (options.input) {
+        // From file
+        const inputPath = path.resolve(process.cwd(), options.input);
+        if (!fs.existsSync(inputPath)) {
+            console.error(`Error: Input file not found: ${options.input}`);
+            process.exit(ExitCode.ERROR);
+        }
+        const content = fs.readFileSync(inputPath, "utf-8");
+        auditResult = JSON.parse(content);
+    }
+    else if (!process.stdin.isTTY) {
+        // From stdin
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        const content = Buffer.concat(chunks).toString("utf-8");
+        auditResult = JSON.parse(content);
+    }
+    else {
+        // Try latest audit file
+        const latestPath = path.resolve(process.cwd(), LATEST_AUDIT_PATH);
+        if (fs.existsSync(latestPath)) {
+            const content = fs.readFileSync(latestPath, "utf-8");
+            auditResult = JSON.parse(content);
+        }
+        else {
+            console.error("Error: No audit results found. Provide --input or pipe results.");
+            process.exit(ExitCode.ERROR);
+        }
+    }
+    // Load baseline if specified
+    let baseline = null;
+    if (options.baseline) {
+        baseline = await loadBaseline(options.baseline);
+    }
+    else {
+        // Try default baseline
+        baseline = await loadBaseline();
+    }
+    // Categorize issues
+    const issues = normalizeIssues(auditResult.issues);
+    const { newIssues, fixedIssues, existingIssues } = categorizeIssuesForComment(issues, baseline);
+    // Build comment data
+    const commentData = {
+        auditId: auditResult.job_id,
+        url: auditResult.url,
+        newIssues,
+        fixedIssues,
+        existingIssues,
+        scores: auditResult.scores,
+    };
+    // Generate output
+    const isJson = options.format === "json";
+    const jsonData = {
+        auditId: auditResult.job_id,
+        url: auditResult.url,
+        newIssues: newIssues.length,
+        existingIssues: existingIssues.length,
+        fixedIssues: fixedIssues.length,
+        issues: {
+            new: newIssues,
+            existing: existingIssues,
+            fixed: fixedIssues,
+        },
+    };
+    let output;
+    if (isJson) {
+        // JSON format - will be wrapped in envelope at output time
+        output = JSON.stringify(jsonData, null, 2);
+    }
+    else {
+        // Markdown format (default)
+        output = formatMarkdownComment(commentData, {
+            groupBy: options.groupBy || "severity",
+            collapse: options.collapse ?? newIssues.length > 3,
+            collapseThreshold: 3,
+            includeEvidence: true,
+            includeFixes: true,
+            baseUrl: "https://vertaaux.ai",
+        });
+    }
+    // Handle posting
+    if (options.post) {
+        // Check if we should skip posting
+        if (options.noPostIfClean && newIssues.length === 0) {
+            console.error("No new issues found. Skipping comment post (--no-post-if-clean).");
+            // Still write output if requested
+            if (options.output) {
+                const outputPath = path.resolve(process.cwd(), options.output);
+                fs.writeFileSync(outputPath, output, "utf-8");
+                console.error(`Comment written to: ${outputPath}`);
+            }
+            return;
+        }
+        // Detect or build CI context
+        let context = null;
+        // Try explicit options first
+        if (options.githubToken || process.env.GITHUB_TOKEN) {
+            const token = options.githubToken || process.env.GITHUB_TOKEN;
+            const repo = options.repo || process.env.GITHUB_REPOSITORY;
+            const prNumber = options.pr || extractPRNumber();
+            if (repo && prNumber) {
+                const parsed = parseRepository(repo);
+                if (parsed) {
+                    context = {
+                        platform: "github",
+                        token,
+                        owner: parsed.owner,
+                        repo: parsed.repo,
+                        prNumber,
+                    };
+                }
+            }
+        }
+        else if (options.gitlabToken || process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN) {
+            const config = getGitLabConfig();
+            if (config) {
+                const mrIid = options.pr || extractMRIid();
+                if (mrIid) {
+                    context = {
+                        platform: "gitlab",
+                        token: config.token,
+                        apiUrl: config.apiUrl,
+                        projectId: config.projectId,
+                        mrIid,
+                    };
+                }
+            }
+        }
+        // Fall back to auto-detection
+        if (!context) {
+            context = detectCIContext();
+        }
+        if (!context) {
+            console.error("Error: Cannot post comment - not in a recognized CI environment.");
+            console.error("Provide --github-token with --repo and --pr, or run in GitHub Actions/GitLab CI.");
+            // Output for debugging via stdout
+            if (isJson) {
+                writeJsonOutput(jsonData, "comment");
+            }
+            else {
+                writeOutput(output);
+            }
+            process.exit(ExitCode.ERROR);
+        }
+        try {
+            const result = await postComment(context, output);
+            console.error(`Comment posted: ${result.url}`);
+        }
+        catch (error) {
+            console.error(`Error posting comment: ${error instanceof Error ? error.message : String(error)}`);
+            // Output for debugging even on failure
+            console.error("\nGenerated output (for debugging):");
+            if (isJson) {
+                writeJsonOutput(jsonData, "comment");
+            }
+            else {
+                writeOutput(output);
+            }
+            process.exit(ExitCode.ERROR);
+        }
+    }
+    // Write output to file or stdout
+    if (options.output) {
+        const outputPath = path.resolve(process.cwd(), options.output);
+        const fileContent = isJson
+            ? JSON.stringify(createEnvelope(jsonData, "comment"), null, 2)
+            : output;
+        fs.writeFileSync(outputPath, fileContent, "utf-8");
+        console.error(`Comment written to: ${outputPath}`);
+    }
+    else if (!options.post) {
+        // Only print to stdout if not posting (posting already logs URL)
+        if (isJson) {
+            writeJsonOutput(jsonData, "comment");
+        }
+        else {
+            writeOutput(output);
+        }
+    }
+}
+/**
+ * Register the comment command with the Commander program.
+ */
+export function registerCommentCommand(program) {
+    program
+        .command("comment")
+        .description("Generate or post PR comment markdown from audit results")
+        .option("--input <file>", "Path to audit results JSON")
+        .option("--baseline <file>", "Path to baseline JSON for diff comparison")
+        .option("--format <type>", "Output format: markdown|json (default: markdown)")
+        .option("-o, --output <file>", "Write to file instead of stdout")
+        .option("--collapse", "Use collapsible sections (default: true for >3 issues)")
+        .option("--no-collapse", "Disable collapsible sections")
+        .option("--group-by <field>", "Group issues by: severity|category|route|file|component (default: severity)")
+        // Posting options
+        .option("--post", "Post/update comment to PR (requires CI context)")
+        .option("--github-token <token>", "GitHub token (default: $GITHUB_TOKEN)")
+        .option("--gitlab-token <token>", "GitLab token (default: $GITLAB_TOKEN or $CI_JOB_TOKEN)")
+        .option("--pr <number>", "PR/MR number (auto-detect from CI env vars)", (val) => parseInt(val, 10))
+        .option("--repo <owner/repo>", "Repository (auto-detect from CI env vars)")
+        .option("--no-post-if-clean", "Don't post comment if no new issues")
+        .action(async (cmdOptions, cmd) => {
+        try {
+            // Validate format using per-command registry
+            const machineMode = cmd.optsWithGlobals?.().machine || false;
+            const validatedFormat = resolveCommandFormat("comment", cmdOptions.format, machineMode);
+            await handleComment({
+                input: cmdOptions.input,
+                baseline: cmdOptions.baseline,
+                format: validatedFormat,
+                output: cmdOptions.output,
+                collapse: cmdOptions.collapse,
+                groupBy: cmdOptions.groupBy,
+                post: cmdOptions.post,
+                githubToken: cmdOptions.githubToken,
+                gitlabToken: cmdOptions.gitlabToken,
+                pr: cmdOptions.pr,
+                repo: cmdOptions.repo,
+                // Commander --no-X flags become X = false
+                noPostIfClean: cmdOptions.postIfClean === false,
+            });
+        }
+        catch (error) {
+            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.exit(ExitCode.ERROR);
+        }
+    });
+}
+// Re-export for backward compatibility
+export { formatMarkdownComment as generateComment } from "../output/markdown.js";

package/dist/commands/diff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Diff command for VertaaUX CLI.
+ *
+ * Compares current audit results against baseline or previous audit.
+ * Shows three categories: new, fixed, still present.
+ *
+ * Exit codes:
+ * - 0: No new issues
+ * - 1: New issues found
+ * - 2: Error
+ */
+import type { Command } from "commander";
+export interface DiffCommandOptions {
+    baseline?: string;
+    compare?: string;
+    format?: string;
+    verbose?: boolean;
+    fromFile?: string;
+}
+/**
+ * Register the diff command with the Commander program.
+ */
+export declare function registerDiffCommand(program: Command): void;
+//# sourceMappingURL=diff.d.ts.map

package/dist/commands/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/commands/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiFzC,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA2I1D"}