@bantay/cli 0.1.1 → 0.3.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@bantay/cli",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Write down the rules your system must never break. We enforce them on every PR.",
   "type": "module",
   "bin": {
-    "bantay": "./src/cli.ts"
+    "bantay": "src/cli.ts"
   },
   "files": [
     "src",
@@ -28,7 +28,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/zcancio/bantay.git"
+    "url": "git+https://github.com/zcancio/bantay.git"
   },
   "dependencies": {
     "js-yaml": "^4.1.0"

package/src/aide/discovery.ts

@@ -0,0 +1,88 @@
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+export interface DiscoveryResult {
+  found: string[];
+  error?: string;
+}
+
+export interface ResolvedAidePath {
+  path: string;
+  filename: string;
+}
+
+/**
+ * Discover .aide files in a directory
+ */
+export async function discoverAideFiles(cwd: string): Promise<DiscoveryResult> {
+  try {
+    const files = await readdir(cwd);
+    const aideFiles = files.filter((f) => f.endsWith(".aide"));
+    return { found: aideFiles };
+  } catch (error) {
+    return { found: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/**
+ * Resolve the aide file path for a project directory
+ * - If explicitPath is provided, use it
+ * - Otherwise, glob for *.aide in projectPath
+ * - If exactly one found, use it
+ * - If multiple found, throw error
+ * - If none found, throw error
+ *
+ * @param projectPath - The project directory to search in
+ * @param explicitPath - Optional explicit path to an aide file
+ * @returns The resolved aide file path
+ * @throws Error if no aide file found or multiple found without explicit path
+ */
+export async function resolveAidePath(
+  projectPath: string,
+  explicitPath?: string
+): Promise<ResolvedAidePath> {
+  // If explicit path provided, use it
+  if (explicitPath) {
+    const fullPath = explicitPath.startsWith("/")
+      ? explicitPath
+      : join(projectPath, explicitPath);
+    const filename = explicitPath.split("/").pop() || explicitPath;
+    return { path: fullPath, filename };
+  }
+
+  // Auto-discover
+  const { found, error } = await discoverAideFiles(projectPath);
+
+  if (error) {
+    throw new Error(`Error discovering aide files: ${error}`);
+  }
+
+  if (found.length === 0) {
+    throw new Error("No .aide file found. Run 'bantay aide init' to create one.");
+  }
+
+  if (found.length > 1) {
+    throw new Error(
+      `Multiple .aide files found. Specify one with --aide <path>\nFound: ${found.join(", ")}`
+    );
+  }
+
+  return {
+    path: join(projectPath, found[0]),
+    filename: found[0],
+  };
+}
+
+/**
+ * Try to resolve aide path, returning null if not found (non-throwing version)
+ */
+export async function tryResolveAidePath(
+  projectPath: string,
+  explicitPath?: string
+): Promise<ResolvedAidePath | null> {
+  try {
+    return await resolveAidePath(projectPath, explicitPath);
+  } catch {
+    return null;
+  }
+}

package/src/aide/index.ts

@@ -16,6 +16,15 @@ import {
 // Re-export types
 export type { AideTree, Entity, Relationship } from "./types";
 
+// Re-export discovery functions
+export {
+  discoverAideFiles,
+  resolveAidePath,
+  tryResolveAidePath,
+  type DiscoveryResult,
+  type ResolvedAidePath,
+} from "./discovery";
+
 /**
  * Read and parse a .aide YAML file
  */

package/src/cli.ts

@@ -3,6 +3,7 @@ import { runInit } from "./commands/init";
 import { runCheck, formatCheckResults, formatCheckResultsJson } from "./commands/check";
 import { checkAllPrerequisites } from "./prerequisites";
 import {
+  handleAideInit,
   handleAideAdd,
   handleAideUpdate,
   handleAideRemove,
@@ -10,9 +11,14 @@ import {
   handleAideShow,
   handleAideValidate,
   handleAideLock,
+  handleAideDiff,
   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";
+import { runTasks, formatTasks } from "./commands/tasks";
+import { handleDiff } from "./commands/diff";
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -33,10 +39,15 @@ 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 if (command === "tasks") {
+    await handleTasks(args.slice(1));
+  } else if (command === "diff") {
+    await handleDiff(args.slice(1));
   } else {
     console.error(`Unknown command: ${command}`);
     console.error('Run "bantay help" for usage information.');
@@ -69,24 +80,34 @@ Usage: bantay <command> [options]
 Commands:
   init      Initialize Bantay in the current project
   check     Check all invariants against the codebase
+  diff      Show classified aide changes (wraps aide diff)
   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
+  tasks     Generate task list from aide CUJs
 
 Options:
   -h, --help    Show this help message
 
 Examples:
   bantay init                Initialize in current directory
+  bantay init --force        Regenerate slash commands
   bantay check               Run full invariant check
   bantay check --diff HEAD~1 Check only affected invariants
+  bantay diff                Show classified aide changes
+  bantay diff --json         Output changes as JSON
   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
+  bantay tasks               Generate tasks for changed CUJs (requires lock)
+  bantay tasks --all         Generate tasks for all CUJs
 
 Run "bantay aide help" for aide subcommand details.
 `);
@@ -95,6 +116,7 @@ Run "bantay aide help" for aide subcommand details.
 async function handleInit(args: string[]) {
   const projectPath = process.cwd();
   const regenerateConfig = args.includes("--regenerate-config");
+  const force = args.includes("--force");
   const dryRun = args.includes("--dry-run");
 
   console.log("Initializing Bantay...\n");
@@ -105,7 +127,7 @@ async function handleInit(args: string[]) {
   }
 
   try {
-    const result = await runInit(projectPath, { regenerateConfig });
+    const result = await runInit(projectPath, { regenerateConfig, force });
 
     // Display detection results
     console.log("Stack Detection:");
@@ -229,14 +251,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);
   }
@@ -262,9 +286,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);
     }
 
@@ -283,6 +311,96 @@ 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 handleTasks(args: string[]) {
+  const projectPath = process.cwd();
+  const allFlag = args.includes("--all");
+
+  // Parse --aide option
+  const aideIndex = args.indexOf("--aide");
+  const aideFile = aideIndex !== -1 ? args[aideIndex + 1] : undefined;
+
+  try {
+    const result = await runTasks(projectPath, { all: allFlag, aide: aideFile });
+    console.log(formatTasks(result));
+    process.exit(0);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Error running tasks:", error);
+    }
+    process.exit(1);
+  }
+}
+
 async function handleAide(args: string[]) {
   const subcommand = args[0];
 
@@ -293,7 +411,9 @@ async function handleAide(args: string[]) {
 
   const subArgs = args.slice(1);
 
-  if (subcommand === "add") {
+  if (subcommand === "init") {
+    await handleAideInit(subArgs);
+  } else if (subcommand === "add") {
     await handleAideAdd(subArgs);
   } else if (subcommand === "update") {
     await handleAideUpdate(subArgs);
@@ -307,6 +427,8 @@ async function handleAide(args: string[]) {
     await handleAideValidate(subArgs);
   } else if (subcommand === "lock") {
     await handleAideLock(subArgs);
+  } else if (subcommand === "diff") {
+    await handleAideDiff(subArgs);
   } else {
     console.error(`Unknown aide subcommand: ${subcommand}`);
     console.error('Run "bantay aide help" for usage information.');