@aigrc/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1029 @@
+// src/commands/scan.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import path from "path";
+import {
+  scan,
+  suggestAssetCard,
+  initializePatterns
+} from "@aigrc/core";
+
+// src/utils/output.ts
+import chalk from "chalk";
+function printHeader() {
+  console.log();
+  console.log(chalk.cyan.bold("AIGRC") + chalk.dim(" - AI Governance, Risk, Compliance"));
+  console.log(chalk.dim("\u2500".repeat(50)));
+  console.log();
+}
+function printSubheader(text) {
+  console.log();
+  console.log(chalk.bold.cyan(`\u25B8 ${text}`));
+  console.log(chalk.cyan("\u2500".repeat(40)));
+}
+function printInfo(text) {
+  console.log(chalk.gray(`\u2139 ${text}`));
+}
+function printScanSummary(result) {
+  const { summary, scannedFiles, skippedFiles, duration } = result;
+  printSubheader("Scan Summary");
+  console.log(`  Files scanned: ${chalk.bold(scannedFiles)}`);
+  if (skippedFiles > 0) {
+    console.log(`  Files skipped: ${chalk.yellow(skippedFiles)}`);
+  }
+  console.log(`  Duration: ${chalk.gray(`${duration}ms`)}`);
+  console.log();
+  if (summary.totalDetections === 0) {
+    printInfo("No AI frameworks or models detected.");
+    return;
+  }
+  console.log(`  ${chalk.bold("Total detections:")} ${summary.totalDetections}`);
+  console.log();
+  console.log(chalk.dim("  By confidence:"));
+  if (summary.byConfidence.high > 0) {
+    console.log(`    ${confidenceLabel("high")}: ${summary.byConfidence.high}`);
+  }
+  if (summary.byConfidence.medium > 0) {
+    console.log(`    ${confidenceLabel("medium")}: ${summary.byConfidence.medium}`);
+  }
+  if (summary.byConfidence.low > 0) {
+    console.log(`    ${confidenceLabel("low")}: ${summary.byConfidence.low}`);
+  }
+  console.log();
+  if (Object.keys(summary.byFramework).length > 0) {
+    console.log(chalk.dim("  By framework:"));
+    for (const [framework, count] of Object.entries(summary.byFramework)) {
+      console.log(`    ${chalk.bold(framework)}: ${count}`);
+    }
+    console.log();
+  }
+  if (summary.primaryFramework) {
+    console.log(
+      `  ${chalk.bold("Primary framework:")} ${chalk.cyan(summary.primaryFramework)}`
+    );
+  }
+  if (summary.primaryCategory) {
+    console.log(
+      `  ${chalk.bold("Primary category:")} ${formatCategory(summary.primaryCategory)}`
+    );
+  }
+}
+function printDetections(detections, verbose = false, limit = 20) {
+  if (detections.length === 0) {
+    return;
+  }
+  printSubheader(`Detections (${detections.length} total)`);
+  const toShow = detections.slice(0, limit);
+  for (const detection of toShow) {
+    const confidence = confidenceLabel(detection.confidence);
+    const location = chalk.gray(`${detection.filePath}:${detection.line}`);
+    const framework = chalk.bold(detection.framework);
+    console.log(`  ${confidence} ${framework}`);
+    console.log(`     ${location}`);
+    console.log(`     ${chalk.dim(truncate(detection.match, 60))}`);
+    if (verbose) {
+      console.log(`     ${chalk.dim(`Strategy: ${detection.strategy}`)}`);
+      if (detection.implies.length > 0) {
+        console.log(
+          `     ${chalk.dim(`Implies: ${detection.implies.map((i) => i.factor).join(", ")}`)}`
+        );
+      }
+    }
+    console.log();
+  }
+  if (detections.length > limit) {
+    printInfo(`... and ${detections.length - limit} more detections`);
+  }
+}
+function printRiskFactors(riskFactors) {
+  printSubheader("Inferred Risk Factors");
+  const factors = [
+    { key: "autonomousDecisions", label: "Autonomous Decisions", value: riskFactors.autonomousDecisions },
+    { key: "customerFacing", label: "Customer Facing", value: riskFactors.customerFacing },
+    { key: "toolExecution", label: "Tool Execution", value: riskFactors.toolExecution },
+    { key: "externalDataAccess", label: "External Data Access", value: riskFactors.externalDataAccess },
+    { key: "piiProcessing", label: "PII Processing", value: riskFactors.piiProcessing },
+    { key: "highStakesDecisions", label: "High-Stakes Decisions", value: riskFactors.highStakesDecisions }
+  ];
+  for (const factor of factors) {
+    const icon = factor.value === true || factor.value === "yes" ? chalk.red("\u25CF") : factor.value === false || factor.value === "no" ? chalk.green("\u25CB") : chalk.yellow("\u25D0");
+    const valueStr = factor.value === true ? chalk.red("Yes") : factor.value === false ? chalk.green("No") : factor.value === "yes" ? chalk.red("Yes") : factor.value === "no" ? chalk.green("No") : chalk.yellow("Unknown");
+    console.log(`  ${icon} ${factor.label}: ${valueStr}`);
+  }
+}
+function confidenceLabel(confidence) {
+  switch (confidence) {
+    case "high":
+      return chalk.green("HIGH  ");
+    case "medium":
+      return chalk.yellow("MEDIUM");
+    case "low":
+      return chalk.gray("LOW   ");
+  }
+}
+function formatCategory(category) {
+  const labels = {
+    llm_provider: "LLM Provider",
+    framework: "Framework",
+    agent_framework: "Agent Framework",
+    ml_framework: "ML Framework",
+    ml_ops: "ML Ops",
+    model_file: "Model File"
+  };
+  return labels[category] ?? category;
+}
+function truncate(text, maxLength) {
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (cleaned.length <= maxLength) {
+    return cleaned;
+  }
+  return cleaned.slice(0, maxLength - 3) + "...";
+}
+function printAssetSuggestion(suggestion) {
+  printSubheader("Asset Card Suggestion");
+  console.log(`  ${chalk.bold("Name:")} ${chalk.cyan(suggestion.name)}`);
+  console.log(`  ${chalk.bold("Description:")} ${suggestion.description}`);
+  console.log(`  ${chalk.bold("Type:")} ${suggestion.technical.type}`);
+  console.log(`  ${chalk.bold("Framework:")} ${suggestion.technical.framework}`);
+  console.log(`  ${chalk.bold("Confidence:")} ${confidenceLabel(suggestion.confidence)}`);
+  console.log();
+  if (suggestion.technical.components.length > 0) {
+    console.log(chalk.dim("  Components:"));
+    for (const comp of suggestion.technical.components) {
+      const details = [comp.type];
+      if (comp.provider) details.push(`provider: ${comp.provider}`);
+      if (comp.model) details.push(`model: ${comp.model}`);
+      console.log(`    - ${details.join(", ")}`);
+    }
+    console.log();
+  }
+  if (Object.keys(suggestion.riskFactors).length > 0) {
+    console.log(chalk.dim("  Risk Factors:"));
+    printRiskFactorsInline(suggestion.riskFactors);
+  }
+}
+function printRiskFactorsInline(riskFactors) {
+  const factors = [
+    { key: "autonomousDecisions", label: "Autonomous", value: riskFactors.autonomousDecisions },
+    { key: "customerFacing", label: "Customer-Facing", value: riskFactors.customerFacing },
+    { key: "toolExecution", label: "Tool Execution", value: riskFactors.toolExecution },
+    { key: "externalDataAccess", label: "External Data", value: riskFactors.externalDataAccess },
+    { key: "piiProcessing", label: "PII", value: riskFactors.piiProcessing },
+    { key: "highStakesDecisions", label: "High-Stakes", value: riskFactors.highStakesDecisions }
+  ];
+  for (const factor of factors) {
+    if (factor.value === void 0) continue;
+    const icon = factor.value === true || factor.value === "yes" ? chalk.red("\u25CF") : factor.value === false || factor.value === "no" ? chalk.green("\u25CB") : chalk.yellow("\u25D0");
+    const valueStr = factor.value === true || factor.value === "yes" ? chalk.red("Yes") : factor.value === false || factor.value === "no" ? chalk.green("No") : chalk.yellow("Unknown");
+    console.log(`    ${icon} ${factor.label}: ${valueStr}`);
+  }
+}
+
+// src/commands/scan.ts
+var scanCommand = new Command("scan").description("Scan a directory for AI/ML frameworks and generate risk assessments").argument("[directory]", "Directory to scan", ".").option("-o, --output <format>", "Output format (text, json, yaml)", "text").option("-v, --verbose", "Show detailed detection information").option("-i, --include <patterns...>", "Include glob patterns").option("-e, --exclude <patterns...>", "Exclude glob patterns").option("-d, --max-depth <depth>", "Maximum directory depth", parseInt).option("-s, --suggest", "Generate asset card suggestion from detections").option("--no-progress", "Disable progress spinner").action(async (directory, options) => {
+  await runScan(directory, options);
+});
+async function runScan(directory, options) {
+  const targetDir = path.resolve(process.cwd(), directory);
+  if (options.output === "text") {
+    printHeader();
+    console.log(chalk2.dim(`Scanning: ${targetDir}
+`));
+  }
+  initializePatterns();
+  const scanOptions = {
+    directory: targetDir,
+    ignorePatterns: options.exclude
+  };
+  let spinner;
+  let lastFile = "";
+  if (options.output === "text" && options.noProgress !== false) {
+    spinner = ora("Scanning...").start();
+  }
+  try {
+    const result = await scan(scanOptions, (progress) => {
+      if (spinner && progress.currentFile !== lastFile) {
+        lastFile = progress.currentFile;
+        const pct = Math.round(progress.scannedFiles / Math.max(progress.totalFiles, 1) * 100);
+        spinner.text = `Scanning (${pct}%): ${path.basename(progress.currentFile)}`;
+      }
+    });
+    spinner?.succeed(`Scanned ${result.scannedFiles} files`);
+    if (options.output === "json") {
+      outputJson(result);
+    } else if (options.output === "yaml") {
+      await outputYaml(result);
+    } else {
+      outputText(result, options);
+    }
+    if (options.suggest && result.detections.length > 0) {
+      const suggestion = suggestAssetCard(result);
+      if (options.output === "json") {
+        console.log(JSON.stringify({ suggestion }, null, 2));
+      } else if (options.output === "yaml") {
+        const { stringify: stringify2 } = await import("yaml");
+        console.log(stringify2({ suggestion }));
+      } else {
+        console.log();
+        printAssetSuggestion(suggestion);
+      }
+    }
+    if (result.summary.byConfidence.high > 0) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    spinner?.fail("Scan failed");
+    if (error instanceof Error) {
+      console.error(chalk2.red(`
+Error: ${error.message}`));
+      if (options.verbose) {
+        console.error(chalk2.dim(error.stack));
+      }
+    }
+    process.exit(1);
+  }
+}
+function outputText(result, options) {
+  console.log();
+  printScanSummary(result);
+  if (result.detections.length > 0) {
+    console.log();
+    printDetections(result.detections, options.verbose);
+  } else {
+    console.log(chalk2.dim("\nNo AI/ML frameworks detected."));
+  }
+  if (result.inferredRiskFactors && Object.keys(result.inferredRiskFactors).length > 0) {
+    console.log();
+    printRiskFactors(result.inferredRiskFactors);
+  }
+}
+function outputJson(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+async function outputYaml(result) {
+  const { stringify: stringify2 } = await import("yaml");
+  console.log(stringify2(result));
+}
+
+// src/commands/init.ts
+import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
+import ora2 from "ora";
+import path2 from "path";
+import fs from "fs/promises";
+import { stringify } from "yaml";
+import {
+  scan as scan2,
+  suggestAssetCard as suggestAssetCard2,
+  initializePatterns as initializePatterns2,
+  createAssetCard,
+  saveAssetCard
+} from "@aigrc/core";
+
+// src/utils/prompts.ts
+import inquirer from "inquirer";
+async function promptForOwner() {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Owner name:",
+      validate: (input) => input.length > 0 || "Name is required"
+    },
+    {
+      type: "input",
+      name: "email",
+      message: "Owner email:",
+      validate: (input) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input) || "Valid email is required"
+    },
+    {
+      type: "input",
+      name: "team",
+      message: "Team name (optional):"
+    }
+  ]);
+  return {
+    name: answers.name,
+    email: answers.email,
+    team: answers.team || void 0
+  };
+}
+async function promptForRegistration(suggestion) {
+  console.log();
+  const basicAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Asset name:",
+      default: suggestion.name,
+      validate: (input) => input.length > 0 || "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: suggestion.description
+    }
+  ]);
+  console.log("\n-- Owner Information --\n");
+  const owner = await promptForOwner();
+  console.log("\n-- Risk Factors --\n");
+  console.log("Based on the scan, the following risk factors were inferred:");
+  console.log();
+  const riskFactorLabels = [
+    { key: "autonomousDecisions", label: "Autonomous Decisions", value: suggestion.riskFactors.autonomousDecisions },
+    { key: "customerFacing", label: "Customer Facing", value: suggestion.riskFactors.customerFacing },
+    { key: "toolExecution", label: "Tool Execution", value: suggestion.riskFactors.toolExecution },
+    { key: "externalDataAccess", label: "External Data Access", value: suggestion.riskFactors.externalDataAccess },
+    { key: "piiProcessing", label: "PII Processing", value: suggestion.riskFactors.piiProcessing },
+    { key: "highStakesDecisions", label: "High-Stakes Decisions", value: suggestion.riskFactors.highStakesDecisions }
+  ];
+  for (const factor of riskFactorLabels) {
+    const value = factor.value === true || factor.value === "yes" ? "Yes" : factor.value === false || factor.value === "no" ? "No" : "Unknown";
+    console.log(`  ${factor.label}: ${value}`);
+  }
+  console.log();
+  const { confirmRiskFactors } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirmRiskFactors",
+      message: "Are these risk factors correct?",
+      default: true
+    }
+  ]);
+  let riskFactorOverrides;
+  if (!confirmRiskFactors) {
+    riskFactorOverrides = await promptForRiskFactorOverrides(suggestion.riskFactors);
+  }
+  return {
+    name: basicAnswers.name,
+    description: basicAnswers.description,
+    owner,
+    confirmRiskFactors,
+    riskFactorOverrides
+  };
+}
+async function promptForRiskFactorOverrides(current) {
+  const answers = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "autonomousDecisions",
+      message: "Does this AI make autonomous decisions?",
+      default: current.autonomousDecisions ?? false
+    },
+    {
+      type: "confirm",
+      name: "customerFacing",
+      message: "Is this AI customer-facing?",
+      default: current.customerFacing ?? false
+    },
+    {
+      type: "confirm",
+      name: "toolExecution",
+      message: "Does this AI execute tools or functions?",
+      default: current.toolExecution ?? false
+    },
+    {
+      type: "confirm",
+      name: "externalDataAccess",
+      message: "Does this AI access external data?",
+      default: current.externalDataAccess ?? false
+    },
+    {
+      type: "list",
+      name: "piiProcessing",
+      message: "Does this AI process PII (personal data)?",
+      choices: [
+        { name: "Yes", value: "yes" },
+        { name: "No", value: "no" },
+        { name: "Unknown", value: "unknown" }
+      ],
+      default: current.piiProcessing ?? "unknown"
+    },
+    {
+      type: "confirm",
+      name: "highStakesDecisions",
+      message: "Does this AI make high-stakes decisions (medical, legal, financial, hiring)?",
+      default: current.highStakesDecisions ?? false
+    }
+  ]);
+  return answers;
+}
+
+// src/commands/init.ts
+var DEFAULT_CONFIG_FILE = ".aigrc.yaml";
+var DEFAULT_CARDS_DIR = ".aigrc/cards";
+var initCommand = new Command2("init").description("Initialize AIGRC in a project - scan, detect, and create asset card").argument("[directory]", "Directory to initialize", ".").option("-f, --force", "Overwrite existing configuration").option("-y, --yes", "Accept all defaults without prompting").option("-o, --output <path>", "Output path for asset card").action(async (directory, options) => {
+  await runInit(directory, options);
+});
+async function runInit(directory, options) {
+  const targetDir = path2.resolve(process.cwd(), directory);
+  printHeader();
+  console.log(chalk3.cyan("Initializing AIGRC in:"), targetDir);
+  console.log();
+  const configPath = path2.join(targetDir, DEFAULT_CONFIG_FILE);
+  const configExists = await fileExists(configPath);
+  if (configExists && !options.force) {
+    console.log(chalk3.yellow("\u26A0 AIGRC already initialized in this directory."));
+    console.log(chalk3.dim(`  Config file: ${configPath}`));
+    console.log(chalk3.dim("  Use --force to reinitialize."));
+    return;
+  }
+  initializePatterns2();
+  const spinner = ora2("Scanning for AI/ML frameworks...").start();
+  try {
+    const result = await scan2({
+      directory: targetDir,
+      ignorePatterns: ["node_modules", ".git", "dist", "build", "__pycache__", ".venv", "venv"]
+    });
+    spinner.succeed(`Found ${result.detections.length} AI/ML detections`);
+    if (result.detections.length === 0) {
+      console.log();
+      console.log(chalk3.yellow("No AI/ML frameworks detected."));
+      console.log(chalk3.dim("You can still create an asset card manually using:"));
+      console.log(chalk3.dim("  aigrc register --manual"));
+      return;
+    }
+    const suggestion = suggestAssetCard2(result);
+    console.log();
+    printAssetSuggestion(suggestion);
+    console.log();
+    let registrationData;
+    if (options.yes) {
+      registrationData = {
+        name: suggestion.name,
+        description: suggestion.description,
+        owner: {
+          name: process.env.USER || process.env.USERNAME || "Unknown",
+          email: `${process.env.USER || process.env.USERNAME || "user"}@example.com`
+        },
+        confirmRiskFactors: true
+      };
+    } else {
+      registrationData = await promptForRegistration(suggestion);
+    }
+    const riskFactors = registrationData.confirmRiskFactors ? suggestion.riskFactors : { ...suggestion.riskFactors, ...registrationData.riskFactorOverrides };
+    const assetCard = createAssetCard({
+      name: registrationData.name,
+      description: registrationData.description,
+      owner: registrationData.owner,
+      technical: {
+        type: suggestion.technical.type,
+        framework: suggestion.technical.framework
+      },
+      riskFactors: {
+        autonomousDecisions: riskFactors.autonomousDecisions ?? false,
+        customerFacing: riskFactors.customerFacing ?? false,
+        toolExecution: riskFactors.toolExecution ?? false,
+        externalDataAccess: riskFactors.externalDataAccess ?? false,
+        piiProcessing: riskFactors.piiProcessing ?? "unknown",
+        highStakesDecisions: riskFactors.highStakesDecisions ?? false
+      }
+    });
+    const cardsDir = path2.join(targetDir, DEFAULT_CARDS_DIR);
+    await fs.mkdir(cardsDir, { recursive: true });
+    const cardFileName = `${sanitizeFileName(assetCard.name)}.yaml`;
+    const cardPath = options.output || path2.join(cardsDir, cardFileName);
+    saveAssetCard(assetCard, cardPath);
+    console.log();
+    console.log(chalk3.green("\u2713 Asset card created:"), chalk3.cyan(cardPath));
+    const config = {
+      version: "1.0",
+      cardsDir: DEFAULT_CARDS_DIR,
+      scan: {
+        exclude: ["node_modules", ".git", "dist", "build", "__pycache__", ".venv", "venv"]
+      }
+    };
+    await fs.writeFile(configPath, stringify(config), "utf-8");
+    console.log(chalk3.green("\u2713 Config file created:"), chalk3.cyan(configPath));
+    console.log();
+    console.log(chalk3.green("AIGRC initialized successfully!"));
+    console.log();
+    console.log(chalk3.dim("Next steps:"));
+    console.log(chalk3.dim("  1. Review and edit the asset card: ") + chalk3.cyan(cardPath));
+    console.log(chalk3.dim("  2. Run ") + chalk3.cyan("aigrc validate") + chalk3.dim(" to check compliance"));
+    console.log(chalk3.dim("  3. Run ") + chalk3.cyan("aigrc status") + chalk3.dim(" to see current status"));
+  } catch (error) {
+    spinner.fail("Initialization failed");
+    if (error instanceof Error) {
+      console.error(chalk3.red(`
+Error: ${error.message}`));
+    }
+    process.exit(1);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sanitizeFileName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/commands/register.ts
+import { Command as Command3 } from "commander";
+import chalk4 from "chalk";
+import path3 from "path";
+import fs2 from "fs/promises";
+import inquirer2 from "inquirer";
+import {
+  createAssetCard as createAssetCard2,
+  saveAssetCard as saveAssetCard2
+} from "@aigrc/core";
+var DEFAULT_CARDS_DIR2 = ".aigrc/cards";
+var registerCommand = new Command3("register").description("Manually register an AI asset without scanning").option("-o, --output <path>", "Output path for asset card").option("-m, --manual", "Skip detection and enter all details manually").action(async (options) => {
+  await runRegister(options);
+});
+async function runRegister(options) {
+  printHeader();
+  console.log(chalk4.cyan("Register a new AI asset\n"));
+  const basicInfo = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Asset name:",
+      validate: (input) => input.length > 0 || "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      validate: (input) => input.length > 0 || "Description is required"
+    },
+    {
+      type: "input",
+      name: "purpose",
+      message: "Business purpose:"
+    }
+  ]);
+  console.log("\n-- Owner Information --\n");
+  const owner = await promptForOwner();
+  console.log("\n-- Risk Factors --\n");
+  const riskFactors = await promptForRiskFactors();
+  console.log("\n-- Framework Information --\n");
+  const frameworks = await promptForFrameworks();
+  const frameworkTypes = {
+    openai: "api_client",
+    anthropic: "api_client",
+    langchain: "framework",
+    llamaindex: "framework",
+    "vercel-ai-sdk": "framework",
+    pytorch: "model",
+    tensorflow: "model",
+    huggingface: "model",
+    crewai: "agent",
+    autogen: "agent"
+  };
+  const primaryFramework = frameworks[0] || "unknown";
+  const technicalType = frameworkTypes[primaryFramework] || "framework";
+  const assetCard = createAssetCard2({
+    name: basicInfo.name,
+    description: basicInfo.description,
+    owner,
+    technical: {
+      type: technicalType,
+      framework: primaryFramework
+    },
+    riskFactors
+  });
+  const cardsDir = path3.join(process.cwd(), DEFAULT_CARDS_DIR2);
+  await fs2.mkdir(cardsDir, { recursive: true });
+  const cardFileName = `${sanitizeFileName2(assetCard.name)}.yaml`;
+  const cardPath = options.output || path3.join(cardsDir, cardFileName);
+  saveAssetCard2(assetCard, cardPath);
+  console.log();
+  console.log(chalk4.green("\u2713 Asset card created:"), chalk4.cyan(cardPath));
+  console.log();
+  console.log(chalk4.dim("Next steps:"));
+  console.log(chalk4.dim("  1. Review and edit the asset card"));
+  console.log(chalk4.dim("  2. Run ") + chalk4.cyan("aigrc validate") + chalk4.dim(" to check compliance"));
+}
+async function promptForRiskFactors() {
+  const answers = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "autonomousDecisions",
+      message: "Does this AI make autonomous decisions?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "customerFacing",
+      message: "Is this AI customer-facing?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "toolExecution",
+      message: "Does this AI execute tools or functions?",
+      default: false
+    },
+    {
+      type: "confirm",
+      name: "externalDataAccess",
+      message: "Does this AI access external data?",
+      default: false
+    },
+    {
+      type: "list",
+      name: "piiProcessing",
+      message: "Does this AI process PII (personal data)?",
+      choices: [
+        { name: "Yes", value: "yes" },
+        { name: "No", value: "no" },
+        { name: "Unknown", value: "unknown" }
+      ],
+      default: "unknown"
+    },
+    {
+      type: "confirm",
+      name: "highStakesDecisions",
+      message: "Does this AI make high-stakes decisions (medical, legal, financial, hiring)?",
+      default: false
+    }
+  ]);
+  return answers;
+}
+async function promptForFrameworks() {
+  const { hasFrameworks } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "hasFrameworks",
+      message: "Do you want to specify AI/ML frameworks used?",
+      default: true
+    }
+  ]);
+  if (!hasFrameworks) {
+    return [];
+  }
+  const { frameworkList } = await inquirer2.prompt([
+    {
+      type: "checkbox",
+      name: "frameworkList",
+      message: "Select frameworks used:",
+      choices: [
+        { name: "OpenAI API", value: "openai" },
+        { name: "Anthropic API", value: "anthropic" },
+        { name: "LangChain", value: "langchain" },
+        { name: "LlamaIndex", value: "llamaindex" },
+        { name: "Vercel AI SDK", value: "vercel-ai-sdk" },
+        { name: "PyTorch", value: "pytorch" },
+        { name: "TensorFlow", value: "tensorflow" },
+        { name: "Hugging Face", value: "huggingface" },
+        { name: "CrewAI", value: "crewai" },
+        { name: "AutoGen", value: "autogen" },
+        { name: "Other", value: "other" }
+      ]
+    }
+  ]);
+  if (frameworkList.includes("other")) {
+    const { otherFrameworks } = await inquirer2.prompt([
+      {
+        type: "input",
+        name: "otherFrameworks",
+        message: "Enter other frameworks (comma-separated):"
+      }
+    ]);
+    const others = otherFrameworks.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
+    return [...frameworkList.filter((f) => f !== "other"), ...others];
+  }
+  return frameworkList;
+}
+function sanitizeFileName2(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+
+// src/commands/validate.ts
+import { Command as Command4 } from "commander";
+import chalk5 from "chalk";
+import ora3 from "ora";
+import path4 from "path";
+import fs3 from "fs/promises";
+import {
+  loadAssetCard,
+  classifyRisk,
+  validateAssetCard
+} from "@aigrc/core";
+var DEFAULT_CARDS_DIR3 = ".aigrc/cards";
+var validateCommand = new Command4("validate").description("Validate asset cards against compliance requirements").argument("[path]", "Path to asset card or cards directory").option("-s, --strict", "Fail on warnings as well as errors").option("-o, --output <format>", "Output format (text, json)", "text").option("-a, --all", "Validate all cards in the cards directory").action(async (cardPath, options) => {
+  await runValidate(cardPath, options);
+});
+async function runValidate(cardPath, options) {
+  if (options.output === "text") {
+    printHeader();
+  }
+  const cardsToValidate = [];
+  if (options.all || !cardPath) {
+    const cardsDir = path4.join(process.cwd(), DEFAULT_CARDS_DIR3);
+    try {
+      const files = await fs3.readdir(cardsDir);
+      const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+      for (const file of yamlFiles) {
+        cardsToValidate.push(path4.join(cardsDir, file));
+      }
+    } catch {
+      if (options.output === "text") {
+        console.log(chalk5.yellow("No cards directory found."));
+        console.log(chalk5.dim(`Expected: ${cardsDir}`));
+        console.log(chalk5.dim("Run `aigrc init` to initialize AIGRC."));
+      } else {
+        console.log(JSON.stringify({ error: "No cards directory found" }));
+      }
+      process.exit(1);
+    }
+  } else {
+    cardsToValidate.push(path4.resolve(process.cwd(), cardPath));
+  }
+  if (cardsToValidate.length === 0) {
+    if (options.output === "text") {
+      console.log(chalk5.yellow("No asset cards found to validate."));
+    } else {
+      console.log(JSON.stringify({ error: "No asset cards found" }));
+    }
+    process.exit(1);
+  }
+  const results = [];
+  let hasErrors = false;
+  for (const cardFile of cardsToValidate) {
+    const spinner = options.output === "text" ? ora3(`Validating ${path4.basename(cardFile)}...`).start() : void 0;
+    try {
+      const card = loadAssetCard(cardFile);
+      const validation = validateAssetCard(card);
+      const classification = classifyRisk(card.classification.riskFactors);
+      results.push({
+        path: cardFile,
+        card,
+        validation: {
+          valid: validation.valid,
+          errors: validation.errors ?? []
+        },
+        classification
+      });
+      if (!validation.valid) {
+        hasErrors = true;
+        spinner?.fail(`${path4.basename(cardFile)}: Invalid`);
+      } else {
+        spinner?.succeed(`${path4.basename(cardFile)}: Valid`);
+      }
+    } catch (error) {
+      hasErrors = true;
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      results.push({
+        path: cardFile,
+        validation: {
+          valid: false,
+          errors: [errorMessage]
+        }
+      });
+      spinner?.fail(`${path4.basename(cardFile)}: Parse error`);
+    }
+  }
+  if (options.output === "json") {
+    console.log(JSON.stringify({ results }, null, 2));
+  } else {
+    console.log();
+    printValidationSummary(results);
+  }
+  if (hasErrors) {
+    process.exit(1);
+  }
+}
+function printValidationSummary(results) {
+  console.log(chalk5.bold("Validation Summary"));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log();
+  for (const result of results) {
+    const fileName = path4.basename(result.path);
+    if (!result.validation.valid) {
+      console.log(chalk5.red(`\u2717 ${fileName}`));
+      for (const error of result.validation.errors) {
+        console.log(chalk5.red(`    Error: ${error}`));
+      }
+    } else {
+      console.log(chalk5.green(`\u2713 ${fileName}`));
+      if (result.card && result.classification) {
+        const tierColor = getRiskLevelColor(result.classification.riskLevel);
+        console.log(
+          chalk5.dim("    Risk Level: ") + tierColor(result.classification.riskLevel)
+        );
+        if (result.classification.euAiActCategory) {
+          console.log(
+            chalk5.dim("    EU AI Act: ") + chalk5.yellow(result.classification.euAiActCategory)
+          );
+        }
+      }
+    }
+    console.log();
+  }
+  const valid = results.filter((r) => r.validation.valid).length;
+  const invalid = results.filter((r) => !r.validation.valid).length;
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log(
+    `Total: ${results.length} | ` + chalk5.green(`Valid: ${valid}`) + ` | ` + chalk5.red(`Invalid: ${invalid}`)
+  );
+}
+function getRiskLevelColor(level) {
+  switch (level) {
+    case "minimal":
+      return chalk5.green;
+    case "limited":
+      return chalk5.yellow;
+    case "high":
+      return chalk5.red;
+    case "unacceptable":
+      return chalk5.magenta;
+    default:
+      return chalk5.white;
+  }
+}
+
+// src/commands/status.ts
+import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
+import path5 from "path";
+import fs4 from "fs/promises";
+import {
+  loadAssetCard as loadAssetCard2,
+  classifyRisk as classifyRisk2
+} from "@aigrc/core";
+var DEFAULT_CARDS_DIR4 = ".aigrc/cards";
+var DEFAULT_CONFIG_FILE2 = ".aigrc.yaml";
+var statusCommand = new Command5("status").description("Show the current AIGRC status and registered assets").option("-o, --output <format>", "Output format (text, json)", "text").action(async (options) => {
+  await runStatus(options);
+});
+async function runStatus(options) {
+  const cwd = process.cwd();
+  if (options.output === "text") {
+    printHeader();
+  }
+  const configPath = path5.join(cwd, DEFAULT_CONFIG_FILE2);
+  const cardsDir = path5.join(cwd, DEFAULT_CARDS_DIR4);
+  const configExists = await fileExists2(configPath);
+  const cardsDirExists = await directoryExists(cardsDir);
+  if (!configExists && !cardsDirExists) {
+    if (options.output === "text") {
+      console.log(chalk6.yellow("AIGRC is not initialized in this directory."));
+      console.log(chalk6.dim("\nRun `aigrc init` to get started."));
+    } else {
+      console.log(JSON.stringify({ initialized: false }));
+    }
+    return;
+  }
+  const cards = [];
+  if (cardsDirExists) {
+    try {
+      const files = await fs4.readdir(cardsDir);
+      const yamlFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+      for (const file of yamlFiles) {
+        try {
+          const filePath = path5.join(cardsDir, file);
+          const card = loadAssetCard2(filePath);
+          const classification = classifyRisk2(card.classification.riskFactors);
+          cards.push({ path: filePath, card, classification });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  if (options.output === "json") {
+    console.log(
+      JSON.stringify(
+        {
+          initialized: true,
+          configPath,
+          cardsDir,
+          cards: cards.map((c) => ({
+            path: c.path,
+            name: c.card.name,
+            id: c.card.id,
+            riskLevel: c.classification.riskLevel,
+            euAiActCategory: c.classification.euAiActCategory
+          }))
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(chalk6.bold("AIGRC Status"));
+  console.log(chalk6.dim("\u2500".repeat(50)));
+  console.log();
+  console.log(chalk6.dim("Config:"), configExists ? chalk6.green("\u2713") : chalk6.red("\u2717"), configPath);
+  console.log(chalk6.dim("Cards:"), cardsDirExists ? chalk6.green("\u2713") : chalk6.red("\u2717"), cardsDir);
+  console.log();
+  if (cards.length === 0) {
+    console.log(chalk6.yellow("No asset cards registered."));
+    console.log(chalk6.dim("\nRun `aigrc init` or `aigrc register` to create an asset card."));
+    return;
+  }
+  console.log(chalk6.bold(`Registered Assets (${cards.length})`));
+  console.log(chalk6.dim("\u2500".repeat(50)));
+  console.log();
+  const byLevel = groupByRiskLevel(cards);
+  for (const level of ["unacceptable", "high", "limited", "minimal"]) {
+    const levelCards = byLevel.get(level);
+    if (!levelCards || levelCards.length === 0) continue;
+    const levelColor = getRiskLevelColor2(level);
+    console.log(levelColor(`${level.toUpperCase()} (${levelCards.length})`));
+    console.log();
+    for (const { card, classification } of levelCards) {
+      console.log(`  ${chalk6.bold(card.name)}`);
+      console.log(chalk6.dim(`    ID: ${card.id}`));
+      console.log(chalk6.dim(`    Risk Level: ${classification.riskLevel}`));
+      if (classification.euAiActCategory) {
+        console.log(chalk6.dim(`    EU AI Act: `) + chalk6.yellow(classification.euAiActCategory));
+      }
+      if (card.ownership?.owner) {
+        console.log(chalk6.dim(`    Owner: ${card.ownership.owner.name} <${card.ownership.owner.email}>`));
+      }
+      const activeRisks = getActiveRiskFactors(card);
+      if (activeRisks.length > 0) {
+        console.log(chalk6.dim(`    Risks: `) + activeRisks.join(", "));
+      }
+      console.log();
+    }
+  }
+  printStatusSummary(cards);
+}
+function groupByRiskLevel(cards) {
+  const byLevel = /* @__PURE__ */ new Map();
+  for (const item of cards) {
+    const level = item.classification.riskLevel;
+    if (!byLevel.has(level)) {
+      byLevel.set(level, []);
+    }
+    byLevel.get(level).push(item);
+  }
+  return byLevel;
+}
+function printStatusSummary(cards) {
+  console.log(chalk6.dim("\u2500".repeat(50)));
+  const minimal = cards.filter((c) => c.classification.riskLevel === "minimal").length;
+  const limited = cards.filter((c) => c.classification.riskLevel === "limited").length;
+  const high = cards.filter((c) => c.classification.riskLevel === "high").length;
+  const unacceptable = cards.filter((c) => c.classification.riskLevel === "unacceptable").length;
+  console.log(
+    `Total: ${cards.length} | ` + chalk6.green(`Minimal: ${minimal}`) + ` | ` + chalk6.yellow(`Limited: ${limited}`) + ` | ` + chalk6.red(`High: ${high}`) + ` | ` + chalk6.magenta(`Unacceptable: ${unacceptable}`)
+  );
+  if (high > 0 || unacceptable > 0) {
+    console.log();
+    console.log(chalk6.yellow("\u26A0 High-risk assets detected. Review compliance requirements."));
+  }
+}
+function getActiveRiskFactors(card) {
+  const risks = [];
+  const rf = card.classification?.riskFactors;
+  if (!rf) return risks;
+  if (rf.autonomousDecisions) risks.push("Autonomous");
+  if (rf.customerFacing) risks.push("Customer-Facing");
+  if (rf.toolExecution) risks.push("Tool Execution");
+  if (rf.externalDataAccess) risks.push("External Data");
+  if (rf.piiProcessing === "yes") risks.push("PII");
+  if (rf.highStakesDecisions) risks.push("High-Stakes");
+  return risks;
+}
+function getRiskLevelColor2(level) {
+  switch (level) {
+    case "minimal":
+      return chalk6.green;
+    case "limited":
+      return chalk6.yellow;
+    case "high":
+      return chalk6.red;
+    case "unacceptable":
+      return chalk6.magenta;
+    default:
+      return chalk6.white;
+  }
+}
+async function fileExists2(filePath) {
+  try {
+    const stat = await fs4.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs4.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+export {
+  initCommand,
+  registerCommand,
+  scanCommand,
+  statusCommand,
+  validateCommand
+};
+//# sourceMappingURL=index.js.map