securevibe 0.1.12 → 0.1.13

package/README.md

@@ -54,6 +54,13 @@ before (`scan`, `fix --apply`, `help`, etc. — the `/` prefix is optional, not
 Up/down arrow cycles through your command history. `scan`/`fix`/`explain` show a single
 live progress spinner instead of scrolling status lines.
 
+Inside the REPL, anything you type that is not a command is a question for the AI about
+your last scan: "why is finding 3 critical?", "which of these should I fix first?".
+Answers are grounded in the scan results only; the assistant never sees your files and
+never claims your code is secure. The first question each session asks before anything
+is sent to your provider. Needs the same key as `fix` and `explain`
+(`securevibe config set-key groq`).
+
 ## Always-on (doc 12)
 
 `securevibe init` makes the tool continuous so insecure code can't slip through:

package/dist/engine/chat.js

@@ -0,0 +1,76 @@
+import { SEVERITY_ORDER } from "./types.js";
+import { llmChatMessages } from "./fix/llm.js";
+/** Findings included in the grounding table, top N by severity then confidence. */
+export const CHAT_MAX_FINDINGS = 30;
+/** Prior exchanges (user + assistant pairs) kept and re-sent per question. */
+export const CHAT_MAX_EXCHANGES = 10;
+const CHAT_SYSTEM = [
+    "You are the assistant inside SecureVibe, a security scanner CLI. The user just scanned their repository; the scan results are below. Answer their questions about those results.",
+    "Rules you must never break:",
+    "- Answer ONLY from the scan results provided. You cannot see the repository's files, only the findings listed. If asked about anything not in them, say you can only see the scan results.",
+    "- Never call the code \"secure\", \"safe\", or \"unhackable\". A clean scan means our detectors found nothing, not that the code is secure.",
+    "- When you give remediation advice, end with: review the diff and run your tests.",
+    "- The user can run these commands: scan, fix (--apply), explain, ai-audit, protect, attack-map, score, deps, ready. Recommend those when relevant. You cannot fix, read files, or run anything yourself; never claim otherwise.",
+    "- Findings are numbered; \"finding 3\" means number 3 in the list below.",
+    "- Keep answers short and concrete: plain prose, no markdown headings, no bullet spam.",
+].join("\n");
+/** The compact, numbered findings table the assistant is grounded in. */
+export function buildGrounding(result) {
+    const sorted = [...result.findings].sort((a, b) => SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity] || b.confidence - a.confidence);
+    const shown = sorted.slice(0, CHAT_MAX_FINDINGS);
+    const lines = [
+        `Target: ${result.root}`,
+        `Score: grade ${result.score.grade} (composite ${result.score.composite}), readiness: ${result.score.readiness}`,
+    ];
+    if (result.launchReadiness) {
+        lines.push(`Launch verdict: ${result.launchReadiness.verdict} (${result.launchReadiness.blockers} blockers, ${result.launchReadiness.warnings} warnings)`);
+    }
+    if (shown.length === 0) {
+        lines.push("Findings: none (no findings — our detectors found nothing; that does not prove the code is secure).");
+        return lines.join("\n");
+    }
+    lines.push(shown.length < sorted.length
+        ? `Findings (top ${shown.length} of ${sorted.length}, by severity):`
+        : `Findings (${shown.length}):`);
+    shown.forEach((f, i) => {
+        lines.push(`${i + 1}. [${f.severity}] ${f.detector} ${f.file}:${f.line} - ${f.title}`);
+        if (f.evidence)
+            lines.push(`   evidence: ${f.evidence.trim()}`);
+    });
+    return lines.join("\n");
+}
+export class ChatSession {
+    callLlm;
+    history = [];
+    grounding = null;
+    constructor(callLlm = llmChatMessages) {
+        this.callLlm = callLlm;
+    }
+    /** New grounding means a fresh conversation: the old answers described old results. */
+    setScanResult(result) {
+        this.grounding = buildGrounding(result);
+        this.history = [];
+    }
+    reset() {
+        this.grounding = null;
+        this.history = [];
+    }
+    /**
+     * Ask one question. Returns null (and leaves history untouched) when there
+     * is no grounding or the call fails — the caller owns the user-facing
+     * degradation message, same contract as llmChat.
+     */
+    async ask(question) {
+        if (this.grounding === null)
+            return null;
+        const messages = [...this.history, { role: "user", content: question }];
+        const answer = await this.callLlm(`${CHAT_SYSTEM}\n\nScan results:\n${this.grounding}`, messages);
+        if (answer == null)
+            return null;
+        this.history.push({ role: "user", content: question }, { role: "assistant", content: answer });
+        const max = CHAT_MAX_EXCHANGES * 2;
+        if (this.history.length > max)
+            this.history = this.history.slice(-max);
+        return answer;
+    }
+}

package/dist/engine/fix/llm.js

@@ -102,22 +102,29 @@ export async function llmFix(input) {
 /**
  * Generic single-turn chat call against whichever provider is configured.
  * Shared by llmFix (full-file rewrites) and engine/explain.ts (plain-language
- * finding explanations) so the Groq/Anthropic HTTP plumbing lives in one place.
- * Returns null on no-provider / network / auth / quota failure — callers degrade
- * gracefully and must never throw because of this.
+ * finding explanations). Returns null on no-provider / network / auth / quota
+ * failure — callers degrade gracefully and must never throw because of this.
  */
 export async function llmChat(system, user) {
+    return llmChatMessages(system, [{ role: "user", content: user }]);
+}
+/**
+ * Multi turn variant: same provider selection and same null-on-failure
+ * contract as llmChat, but takes the full message history. Used by
+ * engine/chat.ts (the REPL's free text chat).
+ */
+export async function llmChatMessages(system, messages) {
     const provider = selectProvider();
     if (!provider)
         return null;
     try {
-        return provider === "groq" ? await callGroq(system, user) : await callAnthropic(system, user);
+        return provider === "groq" ? await callGroq(system, messages) : await callAnthropic(system, messages);
     }
     catch {
         return null;
     }
 }
-async function callAnthropic(system, user) {
+async function callAnthropic(system, messages) {
     let Anthropic;
     try {
         ({ default: Anthropic } = await import("@anthropic-ai/sdk"));
@@ -130,12 +137,12 @@ async function callAnthropic(system, user) {
         model: modelFor("anthropic"),
         max_tokens: 8192,
         system,
-        messages: [{ role: "user", content: user }],
+        messages,
     });
     return extractAnthropicText(msg);
 }
 /** Groq's chat-completions endpoint is OpenAI-compatible — plain fetch, no SDK. */
-async function callGroq(system, user) {
+async function callGroq(system, messages) {
     const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
         method: "POST",
         headers: {
@@ -145,10 +152,7 @@ async function callGroq(system, user) {
         body: JSON.stringify({
             model: modelFor("groq"),
             max_tokens: 8192,
-            messages: [
-                { role: "system", content: system },
-                { role: "user", content: user },
-            ],
+            messages: [{ role: "system", content: system }, ...messages],
         }),
     });
     if (!res.ok)

package/dist/repl.js

@@ -70,27 +70,29 @@ export async function processLine(line, state, io) {
     const cmd = tokens[0];
     const rest = tokens.slice(1);
     try {
-        if (cmd === "exit" || cmd === "quit" || cmd === "q")
+        if ((cmd === "exit" || cmd === "quit" || cmd === "q") && rest.length === 0)
             return true;
-        if (cmd === "help" || cmd === "?") {
+        if ((cmd === "help" || cmd === "?") && rest.length === 0) {
             const { renderHelp } = await import("./ui/repl-tui/commandRegistry.js");
             write(io, renderHelp() + "\n\n");
             return false;
         }
-        if (cmd === "pwd") {
+        if (cmd === "pwd" && rest.length === 0) {
             write(io, `  ${state.root}\n\n`);
             return false;
         }
-        if (cmd === "cd") {
+        if (cmd === "cd" && rest.length <= 1) {
             if (!rest[0]) {
                 write(io, "  usage: cd <path>\n\n");
                 return false;
             }
             state.root = path.resolve(state.root, rest[0]);
+            state.lastResult = undefined; // stale results would ground chat in the wrong repo
+            state.chat?.reset();
             write(io, `  target: ${state.root}\n\n`);
             return false;
         }
-        await dispatch(cmd, rest, state, io);
+        await dispatch(cmd, rest, state, io, trimmed);
     }
     catch (err) {
         write(io, `  error: ${err?.message ?? err}\n\n`);
@@ -118,9 +120,42 @@ function progressCallback(io, asJson) {
         return undefined;
     return io.onProgress ?? ((m) => write(io, `  · ${m}\n`));
 }
-async function dispatch(cmd, tokens, state, io) {
+/**
+ * True when `rest` (the tokens after the command word) is a plausible
+ * argument list for `cmd`'s actual grammar -- known flags/subcommands only.
+ * A command WORD matching a real command but followed by tokens outside its
+ * grammar is natural language that happens to start with that word (e.g.
+ * "score seems too low, why?"), not an invocation -- dispatch() falls
+ * through to chat instead of running the command. Every dispatch-level name
+ * here must also appear in ui/repl-tui/commandRegistry.ts's COMMANDS list;
+ * repl-command-collision.test.ts cross-checks the two so they can't drift.
+ */
+export function matchesCommandGrammar(cmd, rest) {
+    const jsonOnly = new Set(["scan", "ai-audit", "protect", "attack-map", "score", "deps", "ready", "explain"]);
+    if (jsonOnly.has(cmd))
+        return rest.every((t) => t === "--json");
+    if (cmd === "fix") {
+        const known = new Set(["--apply", "--yes", "--no-llm", "--json"]);
+        return rest.every((t) => known.has(t));
+    }
+    if (cmd === "init")
+        return rest.every((t) => t === "--force");
+    if (cmd === "config") {
+        if (rest.length === 0)
+            return true;
+        if (rest[0] === "show")
+            return rest.length === 1;
+        if (rest[0] === "set-key" || rest[0] === "unset-key")
+            return rest.length <= 2;
+        return false;
+    }
+    if (cmd === "db")
+        return rest.length === 0 || (rest.length === 1 && (rest[0] === "update" || rest[0] === "status"));
+    return false;
+}
+async function dispatch(cmd, tokens, state, io, rawLine) {
     const asJson = hasFlag(tokens, "--json");
-    if (["scan", "ai-audit", "protect", "attack-map", "score", "deps", "ready"].includes(cmd)) {
+    if (["scan", "ai-audit", "protect", "attack-map", "score", "deps", "ready"].includes(cmd) && matchesCommandGrammar(cmd, tokens)) {
         const { scan } = await import("./engine/scan.js");
         const usage = await meterOrPrint(io);
         const result = await scan(state.root, {
@@ -128,6 +163,7 @@ async function dispatch(cmd, tokens, state, io) {
             onProgress: progressCallback(io, asJson),
         });
         state.lastResult = result;
+        state.chat?.setScanResult(result);
         if (asJson) {
             const { toJson } = await import("./ui/emit.js");
             write(io, toJson(result) + "\n\n");
@@ -136,7 +172,7 @@ async function dispatch(cmd, tokens, state, io) {
         write(io, (await renderFor(cmd, result, usage)) + "\n");
         return;
     }
-    if (cmd === "fix") {
+    if (cmd === "fix" && matchesCommandGrammar(cmd, tokens)) {
         const { runFix } = await import("./engine/fix/session.js");
         const { renderFixSession, fixToJson, renderApprovalRequest } = await import("./ui/fix.js");
         const opts = { apply: hasFlag(tokens, "--apply"), yes: hasFlag(tokens, "--yes"), json: asJson };
@@ -175,7 +211,7 @@ async function dispatch(cmd, tokens, state, io) {
         }
         return;
     }
-    if (cmd === "explain") {
+    if (cmd === "explain" && matchesCommandGrammar(cmd, tokens)) {
         if (!asJson) {
             if (io.inkMode) {
                 const { noKeyNudgeMessage } = await import("./index-support.js");
@@ -205,7 +241,7 @@ async function dispatch(cmd, tokens, state, io) {
         write(io, renderExplain(report, usage) + "\n");
         return;
     }
-    if (cmd === "init") {
+    if (cmd === "init" && matchesCommandGrammar(cmd, tokens)) {
         const { runInit } = await import("./engine/init.js");
         const { renderInit } = await import("./ui/init.js");
         const result = await runInit(state.root, { force: hasFlag(tokens, "--force") });
@@ -223,15 +259,70 @@ async function dispatch(cmd, tokens, state, io) {
             : undefined);
         return;
     }
-    if (cmd === "config") {
+    if (cmd === "config" && matchesCommandGrammar(cmd, tokens)) {
         await handleConfig(tokens, io);
         return;
     }
-    if (cmd === "db") {
+    if (cmd === "db" && matchesCommandGrammar(cmd, tokens)) {
         await handleDb(tokens, io);
         return;
     }
-    write(io, `  unknown command: ${cmd} (type \`help\`)\n\n`);
+    await handleChat(rawLine, state, io);
+}
+/** Two-space indent so answers sit inside the REPL's output gutter. */
+function indentAnswer(text) {
+    return text
+        .split("\n")
+        .map((l) => "  " + l)
+        .join("\n");
+}
+/**
+ * Free text = a question about the last scan (spec 2026-07-12). Order of
+ * gates: scan first (nothing to talk about), then key (consent would be
+ * pointless without one), then once-per-session consent, then the ask.
+ * NOT metered: no scan runs here and the call spends the user's own key,
+ * the same reasoning that exempts --staged/--diff.
+ */
+async function handleChat(question, state, io) {
+    if (!state.lastResult) {
+        write(io, "  Run `scan` first so I have findings to talk about. (Free text asks the AI about your last scan; type `help` for commands.)\n\n");
+        return;
+    }
+    const { llmAvailability } = await import("./engine/fix/llm.js");
+    const avail = llmAvailability(false);
+    if (!avail.available) {
+        write(io, "  Chat needs an AI key. Run `securevibe config set-key groq` (outside the REPL) to enable it; `explain` and `fix` use the same key.\n\n");
+        return;
+    }
+    if (state.chatConsent === false) {
+        write(io, "  Chat is off for this session (you declined earlier). Commands still work; type `help`.\n\n");
+        return;
+    }
+    if (state.chatConsent === undefined) {
+        const render = (req) => req.kind === "chat-consent"
+            ? `  First question this session: send your questions and the scan findings to ${req.provider}?`
+            : "";
+        const confirm = io.makeConfirm ? io.makeConfirm(render) : makeFixConfirm(render, io.input, io.output);
+        const answer = await confirm({ kind: "chat-consent", provider: avail.provider });
+        state.chatConsent = answer === "yes";
+        if (!state.chatConsent) {
+            write(io, "  Understood, chat stays off for this session. Commands still work; type `help`.\n\n");
+            return;
+        }
+    }
+    if (!state.chat) {
+        const { ChatSession } = await import("./engine/chat.js");
+        state.chat = new ChatSession();
+        state.chat.setScanResult(state.lastResult);
+    }
+    const progress = progressCallback(io, false);
+    progress?.(`asking ${avail.provider}…`);
+    const answer = await state.chat.ask(question);
+    if (answer == null) {
+        write(io, "  The AI call failed; nothing was answered. Try again, or use `explain` for per finding context.\n\n");
+        return;
+    }
+    write(io, indentAnswer(answer) + "\n\n");
 }
 async function renderFor(cmd, result, usage) {
     if (cmd === "scan" || cmd === "ai-audit") {

package/dist/ui/fix.js

@@ -131,7 +131,7 @@ export function renderApprovalRequest(req) {
         L.push(renderDiff(p.relPath, p.before, p.after));
         L.push("  " + pc.dim("verified: finding clears · no new issue · file still parses"));
     }
-    else {
+    else if (req.kind === "side-effects") {
         L.push("");
         L.push("  " + pc.bold("Supporting changes") + pc.dim(" (additive, no break risk)"));
         for (const fx of req.effects) {

package/dist/ui/prompt.js

@@ -26,10 +26,11 @@ export function decideApply(opts, interactive) {
         return { apply: false, prompt: false, notice: true };
     return { apply: true, prompt: true, notice: false };
 }
-/** Map a raw keypress/line to an answer. Empty / unknown → the safe default "no". */
+/** Map a raw keypress/line to an answer. Empty / unknown → the safe default "no".
+ * Only "patch" offers all/quit; side-effects and chat-consent are yes/no. */
 export function mapAnswer(raw, kind) {
     const c = raw.trim().toLowerCase().charAt(0);
-    if (kind === "side-effects")
+    if (kind !== "patch")
         return c === "y" ? "yes" : "no";
     if (c === "y")
         return "yes";
@@ -55,7 +56,9 @@ export function makeFixConfirm(render, input = process.stdin, output = process.s
         output.write(render(req) + "\n");
         const prompt = req.kind === "patch"
             ? "  Apply this change? [y]es / [n]o / [a]ll / [q]uit: "
-            : "  Apply these supporting changes? [y]es / [n]o: ";
+            : req.kind === "side-effects"
+                ? "  Apply these supporting changes? [y]es / [n]o: "
+                : "  Send to your AI provider? [y]es / [n]o: ";
         const raw = await askLine(prompt, input, output);
         return mapAnswer(raw, req.kind);
     };

package/dist/ui/repl-tui/App.js

@@ -118,7 +118,9 @@ export function App({ initialPath }) {
     }), h(Box, { flexDirection: "column" }, h(StatusLine, { targetRoot: stateRef.current.root }), busy && progressMessage ? h(Spinner, { message: progressMessage }) : null, confirmKind
         ? h(Text, { dimColor: true }, confirmKind === "patch"
             ? "  Apply this change? [y]es / [n]o / [a]ll / [q]uit"
-            : "  Apply these supporting changes? [y]es / [n]o")
+            : confirmKind === "side-effects"
+                ? "  Apply these supporting changes? [y]es / [n]o"
+                : "  Send to your AI provider? [y]es / [n]o")
         : null, menuOpen ? h(SlashMenu, { items: filteredCommands, selectedIndex: clampedIndex }) : null, h(InputBox, {
         value,
         onChange: handleChange,

package/dist/ui/repl-tui/commandRegistry.js

@@ -32,5 +32,7 @@ export function renderHelp() {
         const left = `    ${c.name}${c.args ? " " + c.args : ""}`;
         lines.push(left.length < 44 ? left.padEnd(44) + c.description : left + "  " + c.description);
     }
+    lines.push("");
+    lines.push("  Anything else you type is a question for the AI about your last scan (needs a key: `config set-key groq`).");
     return lines.join("\n");
 }

package/dist/version.js

@@ -2,4 +2,4 @@
 // Single source of truth for the CLI's own version, so it can't drift from
 // what commander reports and what the update-check compares against.
 // Kept in sync with the "version" field in package.json by hand at release time.
-export const VERSION = "0.1.12";
+export const VERSION = "0.1.13";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securevibe",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Autonomous AI security engineer for AI generated apps: scan, fix, verify, and gate every commit before you launch",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",