@bantay/cli 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bantay/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Write down the rules your system must never break. We enforce them on every PR.",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -12,7 +12,9 @@ import {
   handleAideLock,
   printAideHelp,
 } from "./commands/aide";
-import { exportInvariants, exportClaude, exportCursor, exportAll } from "./export";
+import { exportInvariants, exportClaude, exportCursor, exportCodex, exportAll } from "./export";
+import { runStatus, formatStatus } from "./commands/status";
+import { runCi, type CiOptions } from "./commands/ci";
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -33,10 +35,11 @@ async function main() {
   } else if (command === "aide") {
     await handleAide(args.slice(1));
   } else if (command === "ci") {
-    console.error("bantay ci: Not yet implemented");
-    process.exit(1);
+    await handleCi(args.slice(1));
   } else if (command === "export") {
     await handleExport(args.slice(1));
+  } else if (command === "status") {
+    await handleStatus(args.slice(1));
   } else {
     console.error(`Unknown command: ${command}`);
     console.error('Run "bantay help" for usage information.');
@@ -72,6 +75,7 @@ Commands:
   aide      Manage the aide entity tree (add, remove, link, show, validate, lock)
   ci        Generate CI workflow configuration
   export    Export invariants to agent context files
+  status    Show scenario implementation status
 
 Options:
   -h, --help    Show this help message
@@ -83,10 +87,12 @@ Examples:
   bantay aide show           Show the aide entity tree
   bantay aide add inv_test --parent invariants --prop "statement=Test"
   bantay ci --github-actions Generate GitHub Actions workflow
-  bantay export all              Export all targets
-  bantay export invariants       Generate invariants.md from bantay.aide
-  bantay export claude           Export to CLAUDE.md
-  bantay export cursor           Export to .cursorrules
+  bantay export all          Export all targets
+  bantay export invariants   Generate invariants.md from bantay.aide
+  bantay export claude       Export to CLAUDE.md
+  bantay export cursor       Export to .cursorrules
+  bantay status              Show scenario implementation status
+  bantay status --json       Output as JSON
 
 Run "bantay aide help" for aide subcommand details.
 `);
@@ -133,6 +139,12 @@ async function handleInit(args: string[]) {
       console.log("  Auth: Not detected");
     }
 
+    if (result.detection.payments) {
+      console.log(`  Payments: ${result.detection.payments.name} (${result.detection.payments.confidence} confidence)`);
+    } else {
+      console.log("  Payments: Not detected");
+    }
+
     console.log("");
 
     // Display warnings
@@ -223,14 +235,16 @@ async function handleExport(args: string[]) {
     console.error("Usage: bantay export <target>");
     console.error("");
     console.error("Targets:");
-    console.error("  all         Export all targets (invariants, claude, cursor)");
+    console.error("  all         Export all targets (invariants, claude, cursor, codex)");
     console.error("  invariants  Generate invariants.md from bantay.aide");
     console.error("  claude      Export to CLAUDE.md with section markers");
     console.error("  cursor      Export to .cursorrules with section markers");
+    console.error("  codex       Export to AGENTS.md with section markers");
     console.error("");
     console.error("Examples:");
     console.error("  bantay export invariants");
     console.error("  bantay export claude");
+    console.error("  bantay export codex");
     console.error("  bantay export --target cursor");
     process.exit(1);
   }
@@ -256,9 +270,13 @@ async function handleExport(args: string[]) {
       const result = await exportCursor(projectPath, { dryRun });
       console.log(`Exported to ${result.outputPath}`);
       console.log(`  ${result.bytesWritten} bytes written`);
+    } else if (target === "codex") {
+      const result = await exportCodex(projectPath, { dryRun });
+      console.log(`Exported to ${result.outputPath}`);
+      console.log(`  ${result.bytesWritten} bytes written`);
     } else {
       console.error(`Unknown export target: ${target}`);
-      console.error('Valid targets: all, invariants, claude, cursor');
+      console.error('Valid targets: all, invariants, claude, cursor, codex');
       process.exit(1);
     }
 
@@ -277,6 +295,74 @@ async function handleExport(args: string[]) {
   }
 }
 
+async function handleCi(args: string[]) {
+  const projectPath = process.cwd();
+
+  // Parse provider from args
+  const hasGitHub = args.includes("--github-actions") || args.includes("--github");
+  const hasGitLab = args.includes("--gitlab");
+  const force = args.includes("--force");
+
+  let provider: "github-actions" | "gitlab" | "generic";
+
+  if (hasGitHub) {
+    provider = "github-actions";
+  } else if (hasGitLab) {
+    provider = "gitlab";
+  } else {
+    provider = "generic";
+  }
+
+  try {
+    const result = await runCi(projectPath, { provider, force });
+
+    if (result.alreadyExists) {
+      console.error(`${result.outputPath} already exists.`);
+      console.error("Use --force to overwrite.");
+      process.exit(1);
+    }
+
+    if (provider === "generic") {
+      console.log(result.content);
+    } else {
+      console.log(`Generated ${result.outputPath}`);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error running ci:", error);
+    }
+    process.exit(1);
+  }
+}
+
+async function handleStatus(args: string[]) {
+  const projectPath = process.cwd();
+  const jsonOutput = args.includes("--json");
+
+  try {
+    const result = await runStatus(projectPath, { json: jsonOutput });
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(formatStatus(result));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error running status:", error);
+    }
+    process.exit(1);
+  }
+}
+
 async function handleAide(args: string[]) {
   const subcommand = args[0];
 

package/src/commands/ci.ts

@@ -0,0 +1,228 @@
+/**
+ * CI workflow generator
+ *
+ * Generates CI configuration for GitHub Actions, GitLab CI, or generic shell commands.
+ */
+
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+
+export interface CiOptions {
+  provider: "github-actions" | "gitlab" | "generic";
+  force?: boolean;
+}
+
+export interface CiResult {
+  provider: string;
+  outputPath?: string;
+  content: string;
+  alreadyExists?: boolean;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generate GitHub Actions workflow YAML
+ */
+function generateGitHubWorkflow(): string {
+  return `name: Bantay Invariant Check
+
+on:
+  pull_request:
+    branches: [main, master]
+  push:
+    branches: [main, master]
+
+jobs:
+  bantay-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Run Bantay check
+        run: bunx @bantay/cli check --json > bantay-results.json 2>&1 || true
+
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        with:
+          name: bantay-results
+          path: bantay-results.json
+
+      - name: Check for failures
+        run: |
+          if grep -q '"status":"fail"' bantay-results.json; then
+            echo "Invariant violations found!"
+            cat bantay-results.json
+            exit 1
+          fi
+          echo "All invariants pass!"
+`;
+}
+
+/**
+ * Generate GitLab CI configuration
+ */
+function generateGitLabConfig(): string {
+  return `# Bantay invariant check stage
+# Add this to your .gitlab-ci.yml
+
+bantay:
+  stage: test
+  image: oven/bun:latest
+  script:
+    - bun install
+    - bunx @bantay/cli check --json > bantay-results.json
+  artifacts:
+    paths:
+      - bantay-results.json
+    reports:
+      dotenv: bantay-results.json
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+    - if: '$CI_COMMIT_BRANCH == "main"'
+    - if: '$CI_COMMIT_BRANCH == "master"'
+`;
+}
+
+/**
+ * Generate generic CI instructions
+ */
+function generateGenericInstructions(): string {
+  return `# Bantay CI Integration
+
+Run these commands in your CI pipeline:
+
+## Install Bun (if not available)
+curl -fsSL https://bun.sh/install | bash
+
+## Install dependencies
+bun install
+
+## Run invariant check
+bunx @bantay/cli check
+
+## For JSON output (recommended for CI parsing)
+bunx @bantay/cli check --json > bantay-results.json
+
+## Exit code
+# - 0: All invariants pass
+# - 1: One or more invariants failed
+# - 2: Configuration error
+
+## Example for common CI systems:
+
+### CircleCI
+# jobs:
+#   bantay:
+#     docker:
+#       - image: oven/bun:latest
+#     steps:
+#       - checkout
+#       - run: bun install
+#       - run: bunx @bantay/cli check
+
+### Jenkins (Jenkinsfile)
+# stage('Bantay Check') {
+#   steps {
+#     sh 'curl -fsSL https://bun.sh/install | bash'
+#     sh 'bun install'
+#     sh 'bunx @bantay/cli check'
+#   }
+# }
+
+### Azure Pipelines
+# - script: |
+#     curl -fsSL https://bun.sh/install | bash
+#     export PATH="$HOME/.bun/bin:$PATH"
+#     bun install
+#     bunx @bantay/cli check
+#   displayName: 'Run Bantay check'
+`;
+}
+
+/**
+ * Run CI generator
+ */
+export async function runCi(
+  projectPath: string,
+  options: CiOptions
+): Promise<CiResult> {
+  const { provider, force } = options;
+
+  if (provider === "github-actions") {
+    const workflowDir = join(projectPath, ".github", "workflows");
+    const outputPath = join(workflowDir, "bantay.yml");
+
+    // Check if file already exists
+    if (await fileExists(outputPath)) {
+      if (!force) {
+        return {
+          provider: "github-actions",
+          outputPath,
+          content: "",
+          alreadyExists: true,
+        };
+      }
+    }
+
+    // Create directory if needed
+    await mkdir(workflowDir, { recursive: true });
+
+    // Generate and write workflow
+    const content = generateGitHubWorkflow();
+    await writeFile(outputPath, content, "utf-8");
+
+    return {
+      provider: "github-actions",
+      outputPath,
+      content,
+    };
+  }
+
+  if (provider === "gitlab") {
+    const outputPath = join(projectPath, ".gitlab-ci.bantay.yml");
+
+    // Check if file already exists
+    if (await fileExists(outputPath)) {
+      if (!force) {
+        return {
+          provider: "gitlab",
+          outputPath,
+          content: "",
+          alreadyExists: true,
+        };
+      }
+    }
+
+    // Generate and write config
+    const content = generateGitLabConfig();
+    await writeFile(outputPath, content, "utf-8");
+
+    return {
+      provider: "gitlab",
+      outputPath,
+      content,
+    };
+  }
+
+  // Generic - just return instructions, don't write file
+  return {
+    provider: "generic",
+    content: generateGenericInstructions(),
+  };
+}

package/src/commands/status.ts

@@ -0,0 +1,309 @@
+import { readFile, readdir, access } from "fs/promises";
+import { join, relative } from "path";
+import * as yaml from "js-yaml";
+
+export interface StatusOptions {
+  json?: boolean;
+}
+
+export interface ScenarioStatus {
+  id: string;
+  name: string;
+  parentCuj: string;
+  status: "implemented" | "missing";
+  testFile?: string;
+  line?: number;
+}
+
+export interface StatusSummary {
+  total: number;
+  implemented: number;
+  missing: number;
+}
+
+export interface StatusResult {
+  scenarios: ScenarioStatus[];
+  summary: StatusSummary;
+  cujs?: Record<string, string>;
+  error?: string;
+}
+
+interface AideEntity {
+  parent?: string;
+  props?: {
+    name?: string;
+    feature?: string;
+    [key: string]: unknown;
+  };
+}
+
+interface AideFile {
+  entities: Record<string, AideEntity>;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function findTestFiles(testsDir: string): Promise<string[]> {
+  const files: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (entry.name.endsWith(".test.ts") || entry.name.endsWith(".test.js")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+      // Directory doesn't exist or isn't readable
+    }
+  }
+
+  await walk(testsDir);
+  return files;
+}
+
+async function searchTestFileForScenario(
+  testFilePath: string,
+  scenarioId: string
+): Promise<{ found: boolean; line?: number }> {
+  try {
+    const content = await readFile(testFilePath, "utf-8");
+    const lines = content.split("\n");
+
+    // Priority 1: Look for explicit scenario marker (highest priority)
+    // Formats: @scenario sc_xxx, // sc_xxx:, // sc_xxx, * @scenario sc_xxx
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (
+        line.includes(`@scenario ${scenarioId}`) ||
+        line.includes(`@scenario: ${scenarioId}`) ||
+        line.includes(`// ${scenarioId}:`) ||
+        line.includes(`// ${scenarioId} `) ||
+        line.match(new RegExp(`\\*\\s*@scenario\\s+${scenarioId}\\b`))
+      ) {
+        return { found: true, line: i + 1 };
+      }
+    }
+
+    // Priority 2: Look for describe/test block containing exact scenario ID
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // Match scenario ID in describe block or test name
+      const isDescribeOrTest = /^\s*(describe|test|it)\s*\(/.test(line);
+      if (isDescribeOrTest && (line.includes(`"${scenarioId}"`) || line.includes(`'${scenarioId}'`))) {
+        return { found: true, line: i + 1 };
+      }
+    }
+
+    return { found: false };
+  } catch {
+    return { found: false };
+  }
+}
+
+function scenarioIdToTestFileName(scenarioId: string): string[] {
+  // Convert sc_init_prerequisites to possible test file names
+  // sc_init_prerequisites -> [prerequisites, init-prerequisites, init]
+  const withoutPrefix = scenarioId.replace(/^sc_/, "");
+  const parts = withoutPrefix.split("_");
+
+  const candidates: string[] = [];
+
+  // Full name with dashes: init-prerequisites
+  candidates.push(parts.join("-"));
+
+  // Last part only: prerequisites
+  if (parts.length > 1) {
+    candidates.push(parts[parts.length - 1]);
+    candidates.push(parts.slice(1).join("-"));
+  }
+
+  // First part only: init
+  candidates.push(parts[0]);
+
+  return candidates;
+}
+
+function testFileMatchesScenario(testFileName: string, scenarioId: string): boolean {
+  const baseName = testFileName.replace(/\.test\.(ts|js)$/, "");
+  const candidates = scenarioIdToTestFileName(scenarioId);
+
+  return candidates.some(candidate => baseName === candidate);
+}
+
+export async function runStatus(
+  projectPath: string,
+  options?: StatusOptions
+): Promise<StatusResult> {
+  const aidePath = join(projectPath, "bantay.aide");
+
+  // Check if aide file exists
+  if (!(await fileExists(aidePath))) {
+    return {
+      scenarios: [],
+      summary: { total: 0, implemented: 0, missing: 0 },
+      error: "bantay.aide not found",
+    };
+  }
+
+  // Parse aide file
+  let aideContent: AideFile;
+  try {
+    const rawContent = await readFile(aidePath, "utf-8");
+    aideContent = yaml.load(rawContent) as AideFile;
+  } catch (e) {
+    return {
+      scenarios: [],
+      summary: { total: 0, implemented: 0, missing: 0 },
+      error: `Failed to parse bantay.aide: ${e instanceof Error ? e.message : String(e)}`,
+    };
+  }
+
+  if (!aideContent?.entities) {
+    return {
+      scenarios: [],
+      summary: { total: 0, implemented: 0, missing: 0 },
+      error: "bantay.aide has no entities",
+    };
+  }
+
+  // Extract CUJ information
+  const cujs: Record<string, string> = {};
+  for (const [id, entity] of Object.entries(aideContent.entities)) {
+    if (id.startsWith("cuj_") && entity.props?.feature) {
+      cujs[id] = entity.props.feature;
+    }
+  }
+
+  // Extract all sc_* entities
+  const scenarios: ScenarioStatus[] = [];
+  for (const [id, entity] of Object.entries(aideContent.entities)) {
+    if (id.startsWith("sc_")) {
+      scenarios.push({
+        id,
+        name: entity.props?.name || id,
+        parentCuj: entity.parent || "unknown",
+        status: "missing",
+      });
+    }
+  }
+
+  // Find test files
+  const testsDir = join(projectPath, "tests");
+  const testFiles = await findTestFiles(testsDir);
+
+  // Match scenarios to test files
+  for (const scenario of scenarios) {
+    // Priority 1: Explicit scenario ID in test file
+    for (const testFile of testFiles) {
+      // Skip status-command.test.ts as it's a meta test that contains scenario IDs as test data
+      if (testFile.includes("status-command.test.ts")) {
+        continue;
+      }
+
+      const result = await searchTestFileForScenario(testFile, scenario.id);
+      if (result.found) {
+        scenario.status = "implemented";
+        scenario.testFile = relative(projectPath, testFile);
+        scenario.line = result.line;
+        break;
+      }
+    }
+
+    // Priority 2: Test file name matches scenario (if not already matched)
+    if (scenario.status === "missing") {
+      for (const testFile of testFiles) {
+        if (testFile.includes("status-command.test.ts")) {
+          continue;
+        }
+
+        const fileName = testFile.split("/").pop() || "";
+        if (testFileMatchesScenario(fileName, scenario.id)) {
+          // Found a file that matches by name, but verify it has relevant tests
+          try {
+            const content = await readFile(testFile, "utf-8");
+            // Ensure it's not an empty or stub test file
+            if (content.includes("describe(") || content.includes("test(")) {
+              scenario.status = "implemented";
+              scenario.testFile = relative(projectPath, testFile);
+              scenario.line = 1; // Start of file when matched by name
+              break;
+            }
+          } catch {
+            // Skip if can't read file
+          }
+        }
+      }
+    }
+  }
+
+  // Calculate summary
+  const implemented = scenarios.filter((s) => s.status === "implemented").length;
+  const missing = scenarios.filter((s) => s.status === "missing").length;
+
+  return {
+    scenarios,
+    summary: {
+      total: scenarios.length,
+      implemented,
+      missing,
+    },
+    cujs,
+  };
+}
+
+export function formatStatus(result: StatusResult): string {
+  if (result.error) {
+    return `Error: ${result.error}\n`;
+  }
+
+  const lines: string[] = [];
+  lines.push("# Scenario Implementation Status\n");
+
+  // Group scenarios by CUJ
+  const byParent: Record<string, ScenarioStatus[]> = {};
+  for (const scenario of result.scenarios) {
+    if (!byParent[scenario.parentCuj]) {
+      byParent[scenario.parentCuj] = [];
+    }
+    byParent[scenario.parentCuj].push(scenario);
+  }
+
+  // Output by CUJ
+  for (const [cuj, scenarios] of Object.entries(byParent)) {
+    const cujName = result.cujs?.[cuj] || cuj;
+    lines.push(`\n## ${cujName}\n`);
+
+    for (const scenario of scenarios) {
+      const icon = scenario.status === "implemented" ? "✓" : "○";
+      const location = scenario.testFile
+        ? `${scenario.testFile}${scenario.line ? `:${scenario.line}` : ""}`
+        : "";
+
+      lines.push(`${icon} ${scenario.id}: ${scenario.name}`);
+      if (location) {
+        lines.push(`  → ${location}`);
+      }
+    }
+  }
+
+  // Summary
+  lines.push(`\n---`);
+  lines.push(
+    `Implemented: ${result.summary.implemented}/${result.summary.total} (${Math.round((result.summary.implemented / result.summary.total) * 100)}%)`
+  );
+  lines.push(`Missing: ${result.summary.missing}`);
+
+  return lines.join("\n");
+}