sentinelayer-cli 0.1.1 → 0.3.0

package/src/interactive/action-menu.js

@@ -0,0 +1,132 @@
+import prompts from "prompts";
+import pc from "picocolors";
+
+import { PERSONA_VISUALS, listPersonaIds } from "../agents/jules/config/definition.js";
+
+/**
+ * Interactive action menu — presented after ingest completes.
+ * Arrow-key navigation for primary actions + submenus.
+ */
+
+/**
+ * Present the main action menu.
+ *
+ * @returns {Promise<{ action: string, subAction?: string, input?: string }>}
+ */
+export async function showActionMenu() {
+  const response = await prompts({
+    type: "select",
+    name: "action",
+    message: "What would you like to do?",
+    choices: [
+      { title: pc.red("🔍 Audit"), value: "audit", description: "Run security + quality audit (baseline + personas)" },
+      { title: pc.yellow("📝 Review"), value: "review", description: "Quick review of current changes" },
+      { title: pc.green("🏗️  Add Feature"), value: "feature", description: "Describe a feature and generate spec + prompt" },
+      { title: pc.blue("🆕 Create Project"), value: "create", description: "Scaffold a new project with spec + Omar Gate" },
+      { title: pc.gray("⚙️  More options..."), value: "more", description: "Config, cost, telemetry, watch, plugins" },
+    ],
+  });
+
+  if (!response.action) return { action: "exit" };
+
+  // Route to submenu
+  if (response.action === "audit") return showAuditMenu();
+  if (response.action === "review") return showReviewMenu();
+  if (response.action === "feature") return showFeaturePrompt();
+  if (response.action === "more") return showMoreMenu();
+
+  return { action: response.action };
+}
+
+/**
+ * Audit submenu — all 13 personas + full audit.
+ */
+async function showAuditMenu() {
+  const personaIds = listPersonaIds();
+  const choices = [
+    {
+      title: pc.bold("🎯 Full Audit (all 13 personas in parallel)"),
+      value: { action: "audit", subAction: "deep" },
+      description: "Omar baseline → 13 specialist agents → reconciliation",
+    },
+  ];
+
+  for (const id of personaIds) {
+    const visual = PERSONA_VISUALS[id];
+    if (!visual) continue;
+    choices.push({
+      title: (visual.avatar || "") + " " + visual.fullName + pc.gray(" (" + id + ")"),
+      value: { action: "audit", subAction: id },
+      description: visual.specialty ? visual.specialty.slice(0, 80) : visual.domain || id,
+    });
+  }
+
+  const response = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Which audit?",
+    choices,
+  });
+
+  return response.choice || { action: "exit" };
+}
+
+/**
+ * Review submenu.
+ */
+async function showReviewMenu() {
+  const response = await prompts({
+    type: "select",
+    name: "choice",
+    message: "Review mode?",
+    choices: [
+      { title: "📋 Full review", value: { action: "review", subAction: "full" }, description: "Scan entire codebase (22-rule deterministic + AI)" },
+      { title: "📝 Diff review", value: { action: "review", subAction: "diff" }, description: "Review only uncommitted changes" },
+      { title: "📌 Staged review", value: { action: "review", subAction: "staged" }, description: "Review only staged files" },
+    ],
+  });
+
+  return response.choice || { action: "exit" };
+}
+
+/**
+ * Feature description prompt.
+ */
+async function showFeaturePrompt() {
+  const response = await prompts({
+    type: "text",
+    name: "description",
+    message: "Describe the feature you want to add:",
+    validate: v => (v && v.trim().length > 5) ? true : "Please describe the feature (at least a few words)",
+  });
+
+  if (!response.description) return { action: "exit" };
+
+  return {
+    action: "feature",
+    input: response.description.trim(),
+  };
+}
+
+/**
+ * More options submenu.
+ */
+async function showMoreMenu() {
+  const response = await prompts({
+    type: "select",
+    name: "choice",
+    message: "More options:",
+    choices: [
+      { title: "📊 Cost & usage summary", value: { action: "cost" }, description: "View token usage and cost tracking" },
+      { title: "📈 Telemetry", value: { action: "telemetry" }, description: "View run event telemetry" },
+      { title: "⚙️  Config", value: { action: "config" }, description: "View and edit configuration" },
+      { title: "👤 Auth status", value: { action: "auth-status" }, description: "Check authentication" },
+      { title: "🔌 Plugins", value: { action: "plugins" }, description: "List installed plugins" },
+      { title: "📡 Watch events", value: { action: "watch" }, description: "Stream runtime events" },
+      { title: "🤖 AI identity", value: { action: "ai" }, description: "AIdenID provisioning" },
+      { title: "🐛 Daemon status", value: { action: "daemon" }, description: "Error queue and budget status" },
+    ],
+  });
+
+  return response.choice || { action: "exit" };
+}

package/src/interactive/auto-ingest.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+
+import { collectCodebaseIngest, generateCodebaseIngest } from "../ingest/engine.js";
+
+/**
+ * Auto-ingest with live progress output.
+ *
+ * Checks if CODEBASE_INGEST.json exists and is fresh.
+ * If stale or missing, runs ingest with real-time status updates.
+ * Returns the ingest result.
+ */
+
+const STALE_THRESHOLD_MS = 300_000; // 5 minutes
+
+/**
+ * Check if ingest exists and is fresh enough.
+ *
+ * @param {string} targetPath - Repository root
+ * @returns {{ exists: boolean, stale: boolean, age: number|null, path: string }}
+ */
+export function checkIngestFreshness(targetPath) {
+  const ingestPath = path.join(targetPath, ".sentinelayer", "CODEBASE_INGEST.json");
+  if (!fs.existsSync(ingestPath)) {
+    return { exists: false, stale: true, age: null, path: ingestPath };
+  }
+
+  try {
+    const stat = fs.statSync(ingestPath);
+    const age = Date.now() - stat.mtimeMs;
+    return {
+      exists: true,
+      stale: age > STALE_THRESHOLD_MS,
+      age,
+      path: ingestPath,
+    };
+  } catch {
+    return { exists: false, stale: true, age: null, path: ingestPath };
+  }
+}
+
+/**
+ * Run auto-ingest with live progress output to stderr.
+ * If ingest exists and is fresh, reads from cache.
+ * Otherwise runs full ingest with status updates.
+ *
+ * @param {string} targetPath
+ * @param {object} [options]
+ * @param {boolean} [options.force] - Force re-ingest even if fresh
+ * @param {boolean} [options.quiet] - Suppress progress output
+ * @returns {Promise<object>} Ingest result
+ */
+export async function autoIngestWithProgress(targetPath, options = {}) {
+  const freshness = checkIngestFreshness(targetPath);
+
+  if (freshness.exists && !freshness.stale && !options.force) {
+    if (!options.quiet) {
+      const ageSec = Math.floor((freshness.age || 0) / 1000);
+      process.stderr.write(pc.gray("Using cached ingest (" + ageSec + "s old)\n"));
+    }
+    try {
+      const cached = JSON.parse(fs.readFileSync(freshness.path, "utf-8"));
+      return cached;
+    } catch { /* fall through to re-ingest */ }
+  }
+
+  // Run ingest with progress
+  if (!options.quiet) {
+    process.stderr.write(pc.cyan("⟳") + " Indexing codebase...\n");
+  }
+
+  const startMs = Date.now();
+
+  if (!options.quiet) {
+    process.stderr.write(pc.gray("  ├─ Scanning files and directories\n"));
+  }
+
+  let ingest;
+  try {
+    ingest = await generateCodebaseIngest({
+      rootPath: targetPath,
+      outputDir: path.join(targetPath, ".sentinelayer"),
+      refresh: true,
+    });
+  } catch {
+    ingest = await collectCodebaseIngest({ rootPath: targetPath });
+  }
+
+  const durationMs = Date.now() - startMs;
+
+  if (!options.quiet) {
+    const files = ingest?.summary?.filesScanned || 0;
+    const loc = ingest?.summary?.totalLoc || 0;
+    const surfaces = (ingest?.riskSurfaces || []).length;
+    const frameworks = (ingest?.frameworks || []).join(", ") || "none";
+
+    process.stderr.write(pc.gray("  ├─ Building AST + import graph\n"));
+    process.stderr.write(pc.gray("  ├─ Assigning domain surfaces\n"));
+    process.stderr.write(pc.gray("  └─ ") + pc.green("Done") + pc.gray(" (" + (durationMs / 1000).toFixed(1) + "s)\n"));
+    process.stderr.write("\n");
+    process.stderr.write(pc.bold("  Codebase Summary\n"));
+    process.stderr.write(pc.gray("  Files: ") + pc.white(String(files)) + "\n");
+    process.stderr.write(pc.gray("  LOC: ") + pc.white(String(loc)) + "\n");
+    process.stderr.write(pc.gray("  Frameworks: ") + pc.white(frameworks) + "\n");
+    process.stderr.write(pc.gray("  Risk surfaces: ") + pc.white(String(surfaces)) + "\n");
+    process.stderr.write("\n");
+  }
+
+  return ingest;
+}

package/src/interactive/index.js

@@ -0,0 +1,95 @@
+import pc from "picocolors";
+import { selectRepo } from "./workspace.js";
+import { autoIngestWithProgress } from "./auto-ingest.js";
+import { showActionMenu } from "./action-menu.js";
+
+/**
+ * Interactive CLI mode — the "sl" experience with no args.
+ *
+ * Flow:
+ * 1. Detect repos in workspace → select if multiple
+ * 2. Auto-ingest with live progress
+ * 3. Present action menu
+ * 4. Route to the selected command
+ */
+
+/**
+ * Run the interactive flow.
+ *
+ * @param {object} [options]
+ * @param {function} [options.executeCommand] - Command executor (receives action + args)
+ * @returns {Promise<void>}
+ */
+export async function runInteractiveMode(options = {}) {
+  console.error("");
+  console.error(pc.bold("  SentinelLayer CLI") + pc.gray(" — security-first development platform"));
+  console.error("");
+
+  // Step 1: Repo selection
+  const repo = await selectRepo();
+  if (!repo) {
+    console.error(pc.yellow("No repository selected. Run sl --help for available commands."));
+    return;
+  }
+
+  // Step 2: Auto-ingest
+  const ingest = await autoIngestWithProgress(repo.path);
+
+  // Step 3: Action menu
+  const choice = await showActionMenu();
+  if (choice.action === "exit") {
+    return;
+  }
+
+  // Step 4: Route to command
+  console.error("");
+  if (options.executeCommand) {
+    await options.executeCommand(choice, repo, ingest);
+  } else {
+    // Print the equivalent CLI command for the user
+    const cmd = buildEquivalentCommand(choice, repo);
+    if (cmd) {
+      console.error(pc.gray("  Equivalent command: ") + pc.cyan(cmd));
+      console.error("");
+    }
+  }
+}
+
+/**
+ * Build the equivalent CLI command string for a menu choice.
+ */
+function buildEquivalentCommand(choice, repo) {
+  const pathFlag = " --path " + repo.path;
+
+  switch (choice.action) {
+    case "audit":
+      if (choice.subAction === "deep") return "sl audit" + pathFlag + " --json";
+      return "sl audit " + choice.subAction + pathFlag + " --stream";
+    case "review":
+      if (choice.subAction === "diff") return "sl review scan --mode diff" + pathFlag + " --json";
+      if (choice.subAction === "staged") return "sl review scan --mode staged" + pathFlag + " --json";
+      return "sl review scan --mode full" + pathFlag + " --json";
+    case "feature":
+      return "sl spec generate --description \"" + (choice.input || "").slice(0, 50) + "...\"" + pathFlag;
+    case "create":
+      return "sl init";
+    case "cost":
+      return "sl cost show" + pathFlag + " --json";
+    case "telemetry":
+      return "sl telemetry show" + pathFlag + " --json";
+    case "config":
+      return "sl config list --json";
+    case "auth-status":
+      return "sl auth status --json";
+    case "plugins":
+      return "sl plugin list --json";
+    case "watch":
+      return "sl watch history" + pathFlag + " --json";
+    case "ai":
+      return "sl ai provision-email --json";
+    case "daemon":
+      return "sl daemon budget status" + pathFlag + " --json";
+    default:
+      return null;
+  }
+}

package/src/interactive/workspace.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import prompts from "prompts";
+import pc from "picocolors";
+
+/**
+ * Multi-repo workspace detection + interactive repo selection.
+ *
+ * Scans the current directory and parent for git repositories.
+ * If multiple found, presents arrow-key selector.
+ * If single found, auto-selects it.
+ */
+
+/**
+ * Detect git repositories in the workspace.
+ * Scans cwd and one level up for directories containing .git.
+ *
+ * @param {string} [startPath] - Starting directory (default: cwd)
+ * @returns {{ repos: Array<{name, path, isCurrentDir}>, parentDir: string }}
+ */
+export function detectRepos(startPath) {
+  const cwd = path.resolve(startPath || process.cwd());
+  const parentDir = path.dirname(cwd);
+  const repos = [];
+
+  // Check if cwd itself is a git repo
+  if (fs.existsSync(path.join(cwd, ".git"))) {
+    repos.push({
+      name: path.basename(cwd),
+      path: cwd,
+      isCurrentDir: true,
+    });
+  }
+
+  // Scan parent directory for sibling repos
+  try {
+    const siblings = fs.readdirSync(parentDir, { withFileTypes: true });
+    for (const entry of siblings) {
+      if (!entry.isDirectory()) continue;
+      const siblingPath = path.join(parentDir, entry.name);
+      if (siblingPath === cwd) continue; // skip self (already added if it's a repo)
+      if (fs.existsSync(path.join(siblingPath, ".git"))) {
+        repos.push({
+          name: entry.name,
+          path: siblingPath,
+          isCurrentDir: false,
+        });
+      }
+    }
+  } catch { /* parent unreadable — only current dir */ }
+
+  return { repos, parentDir };
+}
+
+/**
+ * Interactive repo selector.
+ * If single repo: auto-selects.
+ * If multiple: presents arrow-key menu.
+ * If none: returns null.
+ *
+ * @param {object} [options]
+ * @param {string} [options.startPath]
+ * @returns {Promise<{name, path}|null>}
+ */
+export async function selectRepo(options = {}) {
+  const { repos } = detectRepos(options.startPath);
+
+  if (repos.length === 0) {
+    console.error(pc.yellow("No git repositories found in this workspace."));
+    return null;
+  }
+
+  if (repos.length === 1) {
+    console.error(pc.gray("Repository: " + repos[0].name + " (" + repos[0].path + ")"));
+    return repos[0];
+  }
+
+  // Multiple repos — present selection
+  console.error(pc.bold("Multiple repositories detected:"));
+  const response = await prompts({
+    type: "select",
+    name: "repo",
+    message: "Which repository?",
+    choices: repos.map(r => ({
+      title: r.name + (r.isCurrentDir ? pc.gray(" (current)") : ""),
+      value: r,
+      description: r.path,
+    })),
+  });
+
+  return response.repo || null;
+}