@bantay/cli 0.2.0 → 0.3.1

package/package.json

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

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,11 +11,14 @@ import {
   handleAideShow,
   handleAideValidate,
   handleAideLock,
+  handleAideDiff,
   printAideHelp,
 } from "./commands/aide";
 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];
@@ -40,6 +44,10 @@ async function main() {
     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.');
@@ -72,18 +80,23 @@ 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
@@ -93,6 +106,8 @@ Examples:
   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.
 `);
@@ -101,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");
@@ -111,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:");
@@ -363,6 +379,28 @@ async function handleStatus(args: string[]) {
   }
 }
 
+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];
 
@@ -373,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);
@@ -387,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.');