@bantay/cli 0.1.0 → 0.2.0

package/src/detectors/authjs.ts

@@ -0,0 +1,92 @@
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import type { AuthDetection } 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<AuthDetection | null> {
+  const pkg = await readPackageJson(projectPath);
+
+  let version: string | undefined;
+  let confidence: "high" | "medium" | "low" = "low";
+  let detected = false;
+  let authFunction: string | undefined;
+  let sessionFunction: string | undefined;
+
+  if (pkg) {
+    const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+    const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+
+    // Check for next-auth (Auth.js v4)
+    if (deps["next-auth"]) {
+      version = deps["next-auth"];
+      confidence = "high";
+      detected = true;
+      authFunction = "getServerSession";
+      sessionFunction = "getServerSession(authOptions)";
+    }
+
+    // Check for @auth/nextjs (Auth.js v5)
+    if (deps["@auth/nextjs-auth"]) {
+      version = deps["@auth/nextjs-auth"];
+      confidence = "high";
+      detected = true;
+      authFunction = "auth";
+      sessionFunction = "auth()";
+    }
+
+    // Check for auth.js v5 with new package name
+    if (deps["next-auth"] && version?.startsWith("5")) {
+      authFunction = "auth";
+      sessionFunction = "auth()";
+    }
+  }
+
+  // Check for auth config files
+  const configFiles = [
+    "auth.ts",
+    "auth.config.ts",
+    "lib/auth.ts",
+    "src/auth.ts",
+    "src/lib/auth.ts",
+    "app/api/auth/[...nextauth]/route.ts",
+  ];
+
+  for (const configFile of configFiles) {
+    if (await fileExists(join(projectPath, configFile))) {
+      detected = true;
+      if (confidence === "low") {
+        confidence = "medium";
+      }
+      break;
+    }
+  }
+
+  if (!detected) {
+    return null;
+  }
+
+  return {
+    name: "authjs",
+    version,
+    confidence,
+    authFunction,
+    sessionFunction,
+  };
+}

package/src/detectors/clerk.ts

@@ -0,0 +1,88 @@
+import { readFile, access } from "fs/promises";
+import { join } from "path";
+import type { AuthDetection } 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<AuthDetection | null> {
+  const pkg = await readPackageJson(projectPath);
+
+  let version: string | undefined;
+  let confidence: "high" | "medium" | "low" = "low";
+  let detected = false;
+
+  if (pkg) {
+    const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+    const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+
+    // Check for @clerk/nextjs
+    if (deps["@clerk/nextjs"]) {
+      version = deps["@clerk/nextjs"];
+      confidence = "high";
+      detected = true;
+    } else if (devDeps["@clerk/nextjs"]) {
+      version = devDeps["@clerk/nextjs"];
+      confidence = "medium";
+      detected = true;
+    }
+
+    // Check for @clerk/clerk-sdk-node
+    if (deps["@clerk/clerk-sdk-node"] || devDeps["@clerk/clerk-sdk-node"]) {
+      detected = true;
+      if (confidence === "low") {
+        confidence = "high";
+      }
+    }
+  }
+
+  // Check for Clerk middleware
+  const middlewareFiles = [
+    "middleware.ts",
+    "middleware.js",
+    "src/middleware.ts",
+    "src/middleware.js",
+  ];
+
+  for (const middlewareFile of middlewareFiles) {
+    if (await fileExists(join(projectPath, middlewareFile))) {
+      try {
+        const content = await readFile(join(projectPath, middlewareFile), "utf-8");
+        if (content.includes("@clerk") || content.includes("clerkMiddleware") || content.includes("authMiddleware")) {
+          detected = true;
+          confidence = "high";
+          break;
+        }
+      } catch {
+        // Ignore read errors
+      }
+    }
+  }
+
+  if (!detected) {
+    return null;
+  }
+
+  return {
+    name: "clerk",
+    version,
+    confidence,
+    authFunction: "auth",
+    sessionFunction: "auth()",
+  };
+}

package/src/detectors/drizzle.ts

@@ -0,0 +1,105 @@
+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;
+  }
+}
+
+async function findSchemaPath(projectPath: string): Promise<string | undefined> {
+  // Check common Drizzle schema locations
+  const paths = [
+    "drizzle/schema.ts",
+    "src/db/schema.ts",
+    "src/drizzle/schema.ts",
+    "lib/db/schema.ts",
+    "lib/drizzle/schema.ts",
+    "db/schema.ts",
+    "schema.ts",
+    "src/schema.ts",
+  ];
+
+  for (const path of paths) {
+    if (await fileExists(join(projectPath, path))) {
+      return path;
+    }
+  }
+
+  return undefined;
+}
+
+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;
+
+  if (pkg) {
+    const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+    const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+
+    // Check for drizzle-orm
+    if (deps["drizzle-orm"]) {
+      version = deps["drizzle-orm"];
+      confidence = "high";
+      detected = true;
+    } else if (devDeps["drizzle-orm"]) {
+      version = devDeps["drizzle-orm"];
+      confidence = "medium";
+      detected = true;
+    }
+
+    // Check for drizzle-kit (CLI tool)
+    if (deps["drizzle-kit"] || devDeps["drizzle-kit"]) {
+      detected = true;
+      if (confidence === "low") {
+        confidence = "high";
+      }
+    }
+  }
+
+  // Check for drizzle.config.ts
+  const configFiles = [
+    "drizzle.config.ts",
+    "drizzle.config.js",
+    "drizzle.config.json",
+  ];
+
+  for (const configFile of configFiles) {
+    if (await fileExists(join(projectPath, configFile))) {
+      detected = true;
+      if (confidence === "low") {
+        confidence = "high";
+      }
+      break;
+    }
+  }
+
+  if (!detected) {
+    return null;
+  }
+
+  const schemaPath = await findSchemaPath(projectPath);
+
+  return {
+    name: "drizzle",
+    version,
+    confidence,
+    schemaPath,
+  };
+}

package/src/detectors/index.ts

@@ -2,34 +2,48 @@ export type {
   FrameworkDetection,
   OrmDetection,
   AuthDetection,
+  PaymentsDetection,
   StackDetectionResult,
 } from "./types";
 
-import type { StackDetectionResult, FrameworkDetection, OrmDetection, AuthDetection } from "./types";
+import type { StackDetectionResult, FrameworkDetection, OrmDetection, AuthDetection, PaymentsDetection } from "./types";
 import { detect as detectNextjs } from "./nextjs";
 import { detect as detectPrisma } from "./prisma";
+import { detect as detectDrizzle } from "./drizzle";
+import { detect as detectAuthjs } from "./authjs";
+import { detect as detectClerk } from "./clerk";
+import { detect as detectStripe } from "./stripe";
 
 // Registry of framework detectors
-const frameworkDetectors: Array<() => typeof detectNextjs> = [
-  () => detectNextjs,
+const frameworkDetectors: Array<(projectPath: string) => Promise<FrameworkDetection | null>> = [
+  detectNextjs,
 ];
 
 // Registry of ORM detectors
-const ormDetectors: Array<() => typeof detectPrisma> = [
-  () => detectPrisma,
+const ormDetectors: Array<(projectPath: string) => Promise<OrmDetection | null>> = [
+  detectPrisma,
+  detectDrizzle,
 ];
 
-// Registry of auth detectors (none yet)
-const authDetectors: Array<() => (projectPath: string) => Promise<AuthDetection | null>> = [];
+// Registry of auth detectors
+const authDetectors: Array<(projectPath: string) => Promise<AuthDetection | null>> = [
+  detectClerk,  // Check Clerk first (more specific)
+  detectAuthjs,
+];
+
+// Registry of payments detectors
+const paymentsDetectors: Array<(projectPath: string) => Promise<PaymentsDetection | null>> = [
+  detectStripe,
+];
 
 export async function detectStack(projectPath: string): Promise<StackDetectionResult> {
   let framework: FrameworkDetection | null = null;
   let orm: OrmDetection | null = null;
   let auth: AuthDetection | null = null;
+  let payments: PaymentsDetection | null = null;
 
   // Run framework detectors
-  for (const getDetector of frameworkDetectors) {
-    const detector = getDetector();
+  for (const detector of frameworkDetectors) {
     const result = await detector(projectPath);
     if (result && (!framework || result.confidence === "high")) {
       framework = result;
@@ -38,8 +52,7 @@ export async function detectStack(projectPath: string): Promise<StackDetectionRe
   }
 
   // Run ORM detectors
-  for (const getDetector of ormDetectors) {
-    const detector = getDetector();
+  for (const detector of ormDetectors) {
     const result = await detector(projectPath);
     if (result && (!orm || result.confidence === "high")) {
       orm = result;
@@ -48,8 +61,7 @@ export async function detectStack(projectPath: string): Promise<StackDetectionRe
   }
 
   // Run auth detectors
-  for (const getDetector of authDetectors) {
-    const detector = getDetector();
+  for (const detector of authDetectors) {
     const result = await detector(projectPath);
     if (result && (!auth || result.confidence === "high")) {
       auth = result;
@@ -57,5 +69,14 @@ export async function detectStack(projectPath: string): Promise<StackDetectionRe
     }
   }
 
-  return { framework, orm, auth };
+  // Run payments detectors
+  for (const detector of paymentsDetectors) {
+    const result = await detector(projectPath);
+    if (result && (!payments || result.confidence === "high")) {
+      payments = result;
+      if (result.confidence === "high") break;
+    }
+  }
+
+  return { framework, orm, auth, payments };
 }

package/src/detectors/nextjs.ts

@@ -74,18 +74,27 @@ export async function detect(projectPath: string): Promise<FrameworkDetection |
     return null;
   }
 
-  // Detect router type
+  // Detect router type and determine route pattern
   let router: "app" | "pages" | undefined;
+  let routePattern: string | undefined;
 
   const hasAppDir = await dirExists(join(projectPath, "app"));
   const hasPagesDir = await dirExists(join(projectPath, "pages"));
   const hasSrcAppDir = await dirExists(join(projectPath, "src", "app"));
   const hasSrcPagesDir = await dirExists(join(projectPath, "src", "pages"));
 
-  if (hasAppDir || hasSrcAppDir) {
+  if (hasAppDir) {
     router = "app";
-  } else if (hasPagesDir || hasSrcPagesDir) {
+    routePattern = "app/api/**/route.ts";
+  } else if (hasSrcAppDir) {
+    router = "app";
+    routePattern = "src/app/api/**/route.ts";
+  } else if (hasPagesDir) {
+    router = "pages";
+    routePattern = "pages/api/**/*.ts";
+  } else if (hasSrcPagesDir) {
     router = "pages";
+    routePattern = "src/pages/api/**/*.ts";
   }
 
   return {
@@ -93,5 +102,6 @@ export async function detect(projectPath: string): Promise<FrameworkDetection |
     version,
     confidence,
     router,
+    routePattern,
   };
 }

package/src/detectors/stripe.ts

@@ -0,0 +1,88 @@
+import { readFile, access, readdir } from "fs/promises";
+import { join } from "path";
+import type { PaymentsDetection } 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;
+  }
+}
+
+async function findWebhookPattern(projectPath: string): Promise<string | undefined> {
+  // Check common webhook locations
+  const patterns = [
+    { path: "app/api/webhooks/stripe/route.ts", pattern: "app/api/webhooks/stripe/route.ts" },
+    { path: "app/api/webhook/stripe/route.ts", pattern: "app/api/webhook/stripe/route.ts" },
+    { path: "app/api/stripe/webhook/route.ts", pattern: "app/api/stripe/webhook/route.ts" },
+    { path: "app/webhooks/stripe/route.ts", pattern: "app/webhooks/stripe/route.ts" },
+    { path: "src/app/api/webhooks/stripe/route.ts", pattern: "src/app/api/webhooks/stripe/route.ts" },
+    { path: "pages/api/webhooks/stripe.ts", pattern: "pages/api/webhooks/stripe.ts" },
+    { path: "pages/api/webhook/stripe.ts", pattern: "pages/api/webhook/stripe.ts" },
+  ];
+
+  for (const { path, pattern } of patterns) {
+    if (await fileExists(join(projectPath, path))) {
+      return pattern;
+    }
+  }
+
+  return undefined;
+}
+
+export async function detect(projectPath: string): Promise<PaymentsDetection | null> {
+  const pkg = await readPackageJson(projectPath);
+
+  let version: string | undefined;
+  let confidence: "high" | "medium" | "low" = "low";
+  let detected = false;
+
+  // Check package.json for stripe dependency
+  if (pkg) {
+    const deps = (pkg.dependencies ?? {}) as Record<string, string>;
+    const devDeps = (pkg.devDependencies ?? {}) as Record<string, string>;
+
+    if (deps.stripe) {
+      version = deps.stripe;
+      confidence = "high";
+      detected = true;
+    } else if (devDeps.stripe) {
+      version = devDeps.stripe;
+      confidence = "medium";
+      detected = true;
+    }
+
+    // Also check for @stripe/stripe-js (client-side)
+    if (deps["@stripe/stripe-js"] || devDeps["@stripe/stripe-js"]) {
+      detected = true;
+      if (confidence === "low") {
+        confidence = "medium";
+      }
+    }
+  }
+
+  if (!detected) {
+    return null;
+  }
+
+  const webhookPattern = await findWebhookPattern(projectPath);
+
+  return {
+    name: "stripe",
+    version,
+    confidence,
+    webhookPattern,
+    secretEnvVar: "STRIPE_SECRET_KEY",
+  };
+}

package/src/detectors/types.ts

@@ -3,6 +3,7 @@ export interface FrameworkDetection {
   version?: string;
   confidence: "high" | "medium" | "low";
   router?: "app" | "pages";
+  routePattern?: string; // e.g., "app/api/**/route.ts" or "pages/api/**/*.ts"
 }
 
 export interface OrmDetection {
@@ -16,12 +17,23 @@ export interface AuthDetection {
   name: string;
   version?: string;
   confidence: "high" | "medium" | "low";
+  authFunction?: string; // e.g., "auth()" for Auth.js, "getAuth()" for Clerk
+  sessionFunction?: string; // e.g., "getServerSession()" or "currentUser()"
+}
+
+export interface PaymentsDetection {
+  name: string;
+  version?: string;
+  confidence: "high" | "medium" | "low";
+  webhookPattern?: string; // e.g., "app/api/webhooks/stripe/route.ts"
+  secretEnvVar?: string; // e.g., "STRIPE_SECRET_KEY"
 }
 
 export interface StackDetectionResult {
   framework: FrameworkDetection | null;
   orm: OrmDetection | null;
   auth: AuthDetection | null;
+  payments: PaymentsDetection | null;
 }
 
 export interface Detector<T> {

package/src/export/all.ts

@@ -5,10 +5,11 @@
 import { exportInvariants } from "./invariants";
 import { exportClaude } from "./claude";
 import { exportCursor } from "./cursor";
+import { exportCodex } from "./codex";
 import type { ExportOptions, ExportResult } from "./types";
 
 /**
- * Export all targets: invariants.md, CLAUDE.md, .cursorrules
+ * Export all targets: invariants.md, CLAUDE.md, .cursorrules, AGENTS.md
  */
 export async function exportAll(
   projectPath: string,
@@ -25,5 +26,8 @@ export async function exportAll(
   // Export .cursorrules
   results.push(await exportCursor(projectPath, options));
 
+  // Export AGENTS.md
+  results.push(await exportCodex(projectPath, options));
+
   return results;
 }

package/src/export/codex.ts

@@ -0,0 +1,70 @@
+/**
+ * Export to AGENTS.md with section markers
+ * Works for Codex, Copilot, and any agent that reads AGENTS.md
+ */
+
+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 AGENTS.md
+ */
+export async function exportCodex(
+  projectPath: string,
+  options: ExportOptions = {}
+): Promise<ExportResult> {
+  const aidePath = options.aidePath || join(projectPath, "bantay.aide");
+  const outputPath = options.outputPath || join(projectPath, "AGENTS.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 (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: "codex",
+    outputPath,
+    content,
+    bytesWritten: Buffer.byteLength(content, "utf-8"),
+  };
+}

package/src/export/index.ts

@@ -5,6 +5,7 @@
 export { exportInvariants, generateInvariantsMd } from "./invariants";
 export { exportClaude, generateClaudeSection, insertSection } from "./claude";
 export { exportCursor } from "./cursor";
+export { exportCodex } from "./codex";
 export { exportAll } from "./all";
 
 export type {