@bantay/cli 0.1.0

package/src/detectors/prisma.ts

@@ -0,0 +1,80 @@
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import type { OrmDetection } from "./types";
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readPackageJson(projectPath: string): Promise<Record<string, unknown> | null> {
+  try {
+    const content = await readFile(join(projectPath, "package.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export async function detect(projectPath: string): Promise<OrmDetection | null> {
+  const pkg = await readPackageJson(projectPath);
+
+  let version: string | undefined;
+  let confidence: "high" | "medium" | "low" = "low";
+  let detected = false;
+
+  // Check package.json for prisma dependencies
+  if (pkg) {
+    const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+    const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+
+    if (deps["@prisma/client"]) {
+      version = deps["@prisma/client"];
+      confidence = "high";
+      detected = true;
+    }
+
+    if (devDeps.prisma) {
+      version = version ?? devDeps.prisma;
+      confidence = "high";
+      detected = true;
+    }
+  }
+
+  if (!detected) {
+    return null;
+  }
+
+  // Find schema path
+  let schemaPath: string | undefined;
+
+  // Check for custom path in package.json
+  if (pkg?.prisma && typeof pkg.prisma === "object") {
+    const prismaConfig = pkg.prisma as Record<string, unknown>;
+    if (typeof prismaConfig.schema === "string") {
+      const customPath = prismaConfig.schema;
+      if (await fileExists(join(projectPath, customPath))) {
+        schemaPath = customPath;
+      }
+    }
+  }
+
+  // Check default location if no custom path
+  if (!schemaPath) {
+    const defaultPath = "prisma/schema.prisma";
+    if (await fileExists(join(projectPath, defaultPath))) {
+      schemaPath = defaultPath;
+    }
+  }
+
+  return {
+    name: "prisma",
+    version,
+    confidence,
+    schemaPath,
+  };
+}

package/src/detectors/types.ts

@@ -0,0 +1,29 @@
+export interface FrameworkDetection {
+  name: string;
+  version?: string;
+  confidence: "high" | "medium" | "low";
+  router?: "app" | "pages";
+}
+
+export interface OrmDetection {
+  name: string;
+  version?: string;
+  confidence: "high" | "medium" | "low";
+  schemaPath?: string;
+}
+
+export interface AuthDetection {
+  name: string;
+  version?: string;
+  confidence: "high" | "medium" | "low";
+}
+
+export interface StackDetectionResult {
+  framework: FrameworkDetection | null;
+  orm: OrmDetection | null;
+  auth: AuthDetection | null;
+}
+
+export interface Detector<T> {
+  detect(projectPath: string): Promise<T | null>;
+}

package/src/diff.ts

@@ -0,0 +1,124 @@
+import { join } from "path";
+
+export interface DiffResult {
+  changedFiles: string[];
+  categories: Set<string>;
+}
+
+// Maps file patterns to invariant categories they affect
+const FILE_CATEGORY_MAP: Array<{ pattern: RegExp; category: string }> = [
+  // Route files affect auth invariants
+  { pattern: /\/(api|routes)\/.*\.(ts|tsx|js|jsx)$/, category: "auth" },
+  { pattern: /route\.(ts|tsx|js|jsx)$/, category: "auth" },
+  { pattern: /page\.(ts|tsx|js|jsx)$/, category: "auth" },
+
+  // Schema/migration files affect schema invariants
+  { pattern: /schema\.prisma$/, category: "schema" },
+  { pattern: /migrations?\//, category: "schema" },
+  { pattern: /\.sql$/, category: "schema" },
+
+  // Log-related files affect logging invariants
+  { pattern: /log(ger)?\./, category: "logging" },
+  { pattern: /console\./, category: "logging" },
+];
+
+export async function getGitDiff(
+  projectPath: string,
+  ref: string = "HEAD"
+): Promise<DiffResult> {
+  const changedFiles: string[] = [];
+  const categories = new Set<string>();
+
+  try {
+    // Get list of changed files
+    const proc = Bun.spawn(["git", "diff", "--name-only", ref], {
+      cwd: projectPath,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const output = await new Response(proc.stdout).text();
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      // Also try with staged files for uncommitted changes
+      const stagedProc = Bun.spawn(["git", "diff", "--name-only", "--cached"], {
+        cwd: projectPath,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const stagedOutput = await new Response(stagedProc.stdout).text();
+      await stagedProc.exited;
+
+      const unstagedProc = Bun.spawn(["git", "diff", "--name-only"], {
+        cwd: projectPath,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const unstagedOutput = await new Response(unstagedProc.stdout).text();
+      await unstagedProc.exited;
+
+      const files = new Set([
+        ...stagedOutput.trim().split("\n").filter(Boolean),
+        ...unstagedOutput.trim().split("\n").filter(Boolean),
+      ]);
+
+      changedFiles.push(...files);
+    } else {
+      changedFiles.push(...output.trim().split("\n").filter(Boolean));
+    }
+
+    // Also include untracked files that are new
+    const untrackedProc = Bun.spawn(
+      ["git", "ls-files", "--others", "--exclude-standard"],
+      {
+        cwd: projectPath,
+        stdout: "pipe",
+        stderr: "pipe",
+      }
+    );
+    const untrackedOutput = await new Response(untrackedProc.stdout).text();
+    await untrackedProc.exited;
+
+    const untrackedFiles = untrackedOutput.trim().split("\n").filter(Boolean);
+    for (const file of untrackedFiles) {
+      if (!changedFiles.includes(file)) {
+        changedFiles.push(file);
+      }
+    }
+
+    // Determine which categories are affected
+    for (const file of changedFiles) {
+      for (const { pattern, category } of FILE_CATEGORY_MAP) {
+        if (pattern.test(file)) {
+          categories.add(category);
+        }
+      }
+    }
+
+    // If no specific categories matched but there are changes, include all
+    // This ensures we don't miss invariants for file types we don't recognize
+    if (changedFiles.length > 0 && categories.size === 0) {
+      // Default: check all categories when we can't determine specifics
+      categories.add("*");
+    }
+
+    return { changedFiles, categories };
+  } catch {
+    // Not a git repo or git not available - check everything
+    return { changedFiles: [], categories: new Set(["*"]) };
+  }
+}
+
+export function shouldCheckInvariant(
+  invariantCategory: string,
+  affectedCategories: Set<string>
+): boolean {
+  // If "*" is in affected categories, check everything
+  if (affectedCategories.has("*")) {
+    return true;
+  }
+
+  // Check if this invariant's category is affected
+  return affectedCategories.has(invariantCategory);
+}

package/src/export/aide-reader.ts

@@ -0,0 +1,112 @@
+/**
+ * Helpers to extract entities from the aide tree for export
+ */
+
+import type { AideTree, Entity } from "../aide";
+import type {
+  ExtractedInvariant,
+  ExtractedConstraint,
+  ExtractedFoundation,
+  ExtractedWisdom,
+} from "./types";
+
+/**
+ * Extract all invariants from the aide tree
+ * Invariants are entities with parent "invariants"
+ */
+export function extractInvariants(tree: AideTree): ExtractedInvariant[] {
+  const invariants: ExtractedInvariant[] = [];
+
+  for (const [id, entity] of Object.entries(tree.entities)) {
+    if (entity.parent === "invariants" && entity.props) {
+      const props = entity.props;
+      invariants.push({
+        id,
+        statement: String(props.statement || ""),
+        category: String(props.category || "uncategorized"),
+        threatSignal: props.threat_signal ? String(props.threat_signal) : undefined,
+        done: props.done === true,
+      });
+    }
+  }
+
+  return invariants;
+}
+
+/**
+ * Extract all constraints from the aide tree
+ * Constraints are entities with parent "constraints"
+ */
+export function extractConstraints(tree: AideTree): ExtractedConstraint[] {
+  const constraints: ExtractedConstraint[] = [];
+
+  for (const [id, entity] of Object.entries(tree.entities)) {
+    if (entity.parent === "constraints" && entity.props) {
+      const props = entity.props;
+      constraints.push({
+        id,
+        text: String(props.text || ""),
+        domain: String(props.domain || "general"),
+        rationale: props.rationale ? String(props.rationale) : undefined,
+      });
+    }
+  }
+
+  return constraints;
+}
+
+/**
+ * Extract all foundations from the aide tree
+ * Foundations are entities with parent "foundations"
+ */
+export function extractFoundations(tree: AideTree): ExtractedFoundation[] {
+  const foundations: ExtractedFoundation[] = [];
+
+  for (const [id, entity] of Object.entries(tree.entities)) {
+    if (entity.parent === "foundations" && entity.props) {
+      const props = entity.props;
+      foundations.push({
+        id,
+        text: String(props.text || ""),
+      });
+    }
+  }
+
+  return foundations;
+}
+
+/**
+ * Extract all wisdom entries from the aide tree
+ * Wisdom entries are entities with parent "wisdom"
+ */
+export function extractWisdom(tree: AideTree): ExtractedWisdom[] {
+  const wisdom: ExtractedWisdom[] = [];
+
+  for (const [id, entity] of Object.entries(tree.entities)) {
+    if (entity.parent === "wisdom" && entity.props) {
+      const props = entity.props;
+      wisdom.push({
+        id,
+        text: String(props.text || ""),
+      });
+    }
+  }
+
+  return wisdom;
+}
+
+/**
+ * Group items by a key
+ */
+export function groupBy<T>(items: T[], keyFn: (item: T) => string): Map<string, T[]> {
+  const groups = new Map<string, T[]>();
+
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = groups.get(key) || [];
+    existing.push(item);
+    groups.set(key, existing);
+  }
+
+  return groups;
+}

package/src/export/all.ts

@@ -0,0 +1,29 @@
+/**
+ * Export all targets at once
+ */
+
+import { exportInvariants } from "./invariants";
+import { exportClaude } from "./claude";
+import { exportCursor } from "./cursor";
+import type { ExportOptions, ExportResult } from "./types";
+
+/**
+ * Export all targets: invariants.md, CLAUDE.md, .cursorrules
+ */
+export async function exportAll(
+  projectPath: string,
+  options: ExportOptions = {}
+): Promise<ExportResult[]> {
+  const results: ExportResult[] = [];
+
+  // Export invariants.md
+  results.push(await exportInvariants(projectPath, options));
+
+  // Export CLAUDE.md
+  results.push(await exportClaude(projectPath, options));
+
+  // Export .cursorrules
+  results.push(await exportCursor(projectPath, options));
+
+  return results;
+}

package/src/export/claude.ts

@@ -0,0 +1,221 @@
+/**
+ * Export to CLAUDE.md with section markers
+ */
+
+import { readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+import { read as readAide } from "../aide";
+import {
+  extractConstraints,
+  extractFoundations,
+  extractInvariants,
+  groupBy,
+} from "./aide-reader";
+import {
+  type ExportOptions,
+  type ExportResult,
+  type ExtractedConstraint,
+  type ExtractedFoundation,
+  type ExtractedInvariant,
+  SECTION_START,
+  SECTION_END,
+} from "./types";
+
+/**
+ * Generate the Bantay section content for CLAUDE.md
+ */
+export function generateClaudeSection(
+  constraints: ExtractedConstraint[],
+  foundations: ExtractedFoundation[],
+  invariants: ExtractedInvariant[]
+): string {
+  const lines: string[] = [];
+
+  lines.push(SECTION_START);
+  lines.push("");
+  lines.push("## Bantay Project Rules");
+  lines.push("");
+  lines.push("*Auto-generated from bantay.aide. Do not edit manually.*");
+  lines.push("");
+
+  // Foundations as principles
+  if (foundations.length > 0) {
+    lines.push("### Design Principles");
+    lines.push("");
+    for (const f of foundations) {
+      lines.push(`- ${f.text}`);
+    }
+    lines.push("");
+  }
+
+  // Constraints grouped by domain
+  if (constraints.length > 0) {
+    lines.push("### Architectural Constraints");
+    lines.push("");
+
+    const byDomain = groupBy(constraints, (c) => c.domain);
+    const sortedDomains = Array.from(byDomain.keys()).sort();
+
+    for (const domain of sortedDomains) {
+      const domainConstraints = byDomain.get(domain) || [];
+
+      lines.push(`#### ${formatDomainTitle(domain)}`);
+      lines.push("");
+
+      for (const c of domainConstraints) {
+        lines.push(`- **${c.id}**: ${c.text}`);
+        if (c.rationale) {
+          lines.push(`  - *Rationale*: ${c.rationale}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+
+  // Invariants as rules
+  if (invariants.length > 0) {
+    lines.push("### Invariants (Rules You Must Follow)");
+    lines.push("");
+
+    const byCategory = groupBy(invariants, (inv) => inv.category);
+    const sortedCategories = Array.from(byCategory.keys()).sort();
+
+    for (const category of sortedCategories) {
+      const categoryInvariants = byCategory.get(category) || [];
+
+      lines.push(`#### ${formatCategoryTitle(category)}`);
+      lines.push("");
+
+      for (const inv of categoryInvariants) {
+        lines.push(`- **${inv.id}**: ${inv.statement}`);
+      }
+      lines.push("");
+    }
+  }
+
+  lines.push(SECTION_END);
+
+  return lines.join("\n");
+}
+
+/**
+ * Format a domain ID into a readable title
+ */
+function formatDomainTitle(domain: string): string {
+  return domain
+    .split("_")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+/**
+ * Format a category ID into a readable title
+ */
+function formatCategoryTitle(category: string): string {
+  return category
+    .split("_")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(" ");
+}
+
+/**
+ * Find the position of a marker at the start of a line (not inline)
+ * Returns -1 if not found
+ */
+function findMarkerPosition(content: string, marker: string): number {
+  // Match marker at start of line (with optional leading whitespace)
+  const regex = new RegExp(`^[ \\t]*${escapeRegex(marker)}`, "m");
+  const match = content.match(regex);
+  if (match && match.index !== undefined) {
+    // Return the position of the marker itself, not the leading whitespace
+    return content.indexOf(marker, match.index);
+  }
+  return -1;
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Insert or replace the Bantay section in a file
+ * Only matches markers at the start of a line, not inline markers
+ */
+export function insertSection(existingContent: string, newSection: string): string {
+  const startIdx = findMarkerPosition(existingContent, SECTION_START);
+  const endIdx = findMarkerPosition(existingContent, SECTION_END);
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    // Replace existing section
+    const before = existingContent.slice(0, startIdx);
+    const after = existingContent.slice(endIdx + SECTION_END.length);
+    return before + newSection + after;
+  }
+
+  // Append section at end
+  if (existingContent.length > 0 && !existingContent.endsWith("\n")) {
+    return existingContent + "\n\n" + newSection + "\n";
+  }
+  if (existingContent.length > 0) {
+    return existingContent + "\n" + newSection + "\n";
+  }
+  return newSection + "\n";
+}
+
+/**
+ * Check if a file exists
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Export to CLAUDE.md
+ */
+export async function exportClaude(
+  projectPath: string,
+  options: ExportOptions = {}
+): Promise<ExportResult> {
+  const aidePath = options.aidePath || join(projectPath, "bantay.aide");
+  const outputPath = options.outputPath || join(projectPath, "CLAUDE.md");
+
+  // Read the aide tree
+  const tree = await readAide(aidePath);
+
+  // Extract entities
+  const constraints = extractConstraints(tree);
+  const foundations = extractFoundations(tree);
+  const invariants = extractInvariants(tree);
+
+  // Generate section content
+  const section = generateClaudeSection(constraints, foundations, invariants);
+
+  // Read existing file if it exists
+  let existingContent = "";
+  if (await fileExists(outputPath)) {
+    existingContent = await readFile(outputPath, "utf-8");
+  }
+
+  // Insert or replace section
+  const content = insertSection(existingContent, section);
+
+  // Write unless dry run
+  if (!options.dryRun) {
+    await writeFile(outputPath, content, "utf-8");
+  }
+
+  return {
+    target: "claude",
+    outputPath,
+    content,
+    bytesWritten: Buffer.byteLength(content, "utf-8"),
+  };
+}

package/src/export/cursor.ts

@@ -0,0 +1,69 @@
+/**
+ * Export to .cursorrules with section markers
+ */
+
+import { readFile, writeFile, access } from "fs/promises";
+import { join } from "path";
+import { read as readAide } from "../aide";
+import {
+  extractConstraints,
+  extractFoundations,
+  extractInvariants,
+} from "./aide-reader";
+import { generateClaudeSection, insertSection } from "./claude";
+import type { ExportOptions, ExportResult } from "./types";
+
+/**
+ * Check if a file exists
+ */
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Export to .cursorrules
+ */
+export async function exportCursor(
+  projectPath: string,
+  options: ExportOptions = {}
+): Promise<ExportResult> {
+  const aidePath = options.aidePath || join(projectPath, "bantay.aide");
+  const outputPath = options.outputPath || join(projectPath, ".cursorrules");
+
+  // Read the aide tree
+  const tree = await readAide(aidePath);
+
+  // Extract entities
+  const constraints = extractConstraints(tree);
+  const foundations = extractFoundations(tree);
+  const invariants = extractInvariants(tree);
+
+  // Generate section content (same format as claude)
+  const section = generateClaudeSection(constraints, foundations, invariants);
+
+  // Read existing file if it exists
+  let existingContent = "";
+  if (await fileExists(outputPath)) {
+    existingContent = await readFile(outputPath, "utf-8");
+  }
+
+  // Insert or replace section
+  const content = insertSection(existingContent, section);
+
+  // Write unless dry run
+  if (!options.dryRun) {
+    await writeFile(outputPath, content, "utf-8");
+  }
+
+  return {
+    target: "cursor",
+    outputPath,
+    content,
+    bytesWritten: Buffer.byteLength(content, "utf-8"),
+  };
+}

package/src/export/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Export module - generates output files from bantay.aide
+ */
+
+export { exportInvariants, generateInvariantsMd } from "./invariants";
+export { exportClaude, generateClaudeSection, insertSection } from "./claude";
+export { exportCursor } from "./cursor";
+export { exportAll } from "./all";
+
+export type {
+  ExportOptions,
+  ExportResult,
+  ExportTarget,
+  ExtractedInvariant,
+  ExtractedConstraint,
+  ExtractedFoundation,
+  ExtractedWisdom,
+} from "./types";
+
+export { SECTION_START, SECTION_END } from "./types";
+
+export {
+  extractInvariants,
+  extractConstraints,
+  extractFoundations,
+  extractWisdom,
+  groupBy,
+} from "./aide-reader";