muonroi-cli 1.3.4 → 1.4.1

package/dist/src/pil/discovery.js

@@ -0,0 +1,341 @@
+import { randomUUID } from "node:crypto";
+import { shouldAutoPass } from "./clarity-gate.js";
+import { getMaxInterviewQuestions, isDiscoveryEnabled } from "./config.js";
+import { getCachedProjectContext, setCachedProjectContext } from "./discovery-cache.js";
+import { isMetaAnalysisPrompt } from "./layer6-output.js";
+import { scanProjectContext } from "./layer15-context-scan.js";
+import { buildInterviewQuestion, detectClarityGaps, getAutofilledOutcome, resolveGapsNonInteractive, } from "./layer16-clarity.js";
+import { checkFeasibility } from "./layer17-feasibility.js";
+import { buildAcceptanceCard, buildAcceptanceQuestion } from "./layer18-acceptance.js";
+import { getSessionState, isLikelyFollowUp, markDiscoveryAccepted } from "./session-state.js";
+function emptyProjectContext(cwd) {
+    return {
+        language: null,
+        framework: null,
+        packageManager: null,
+        domain: null,
+        boundedContexts: [],
+        eePatterns: [],
+        relevantModules: [],
+        scannedAt: Date.now(),
+        cwd,
+    };
+}
+export async function runDiscovery(raw, l1, cwd, handler, sessionId = null, clarificationProposer = null, recentTurnsSummary = null) {
+    const start = Date.now();
+    const baseResult = () => ({
+        raw,
+        projectContext: emptyProjectContext(cwd),
+        clarifiedIntent: { outcome: raw, scope: [], constraints: [], gaps: [] },
+        feasibility: { viable: true, warnings: [], adjustedScope: [] },
+        interviewed: false,
+        intentStatement: raw,
+        outcome: raw,
+        scope: [],
+        feasibilityWarnings: [],
+        accepted: true,
+        taskType: l1.taskType,
+        confidence: l1.confidence,
+        domain: l1.domain,
+        outputStyle: l1.outputStyle,
+        discoveryMs: Date.now() - start,
+    });
+    if (!isDiscoveryEnabled())
+        return baseResult();
+    if (l1.intentKind === "chitchat" || l1.taskType === null)
+        return baseResult();
+    // Session-continuation guard: when the user is on turn >= 2 of an ongoing
+    // session AND the new prompt looks like a continuation (short, modal verb
+    // or context pronoun), skip the interview entirely. The prior turn already
+    // established context; asking "Which part of the codebase?" on "Can you
+    // fix it?" forces the user to re-type their intent as a freetext answer,
+    // which PIL then mis-routes through gap-resolution + acceptance, producing
+    // duplicate askcards (evidence: session 1f29e238a816 timeline).
+    const sessionState = getSessionState(sessionId);
+    if (sessionState && sessionState.turnCount > 1 && isLikelyFollowUp(raw)) {
+        return baseResult();
+    }
+    const l1Signal = { confidence: l1.confidence, taskType: l1.taskType, complexity: l1.complexity };
+    if (shouldAutoPass(l1Signal, raw))
+        return baseResult();
+    // L1.5: Context Discovery (cacheable)
+    let projectContext;
+    const cached = getCachedProjectContext(cwd);
+    if (cached) {
+        projectContext = cached;
+    }
+    else {
+        try {
+            projectContext = await Promise.race([
+                scanProjectContext(raw, cwd),
+                new Promise((resolve) => setTimeout(() => resolve(emptyProjectContext(cwd)), 500)),
+            ]);
+            setCachedProjectContext(projectContext);
+        }
+        catch {
+            projectContext = emptyProjectContext(cwd);
+        }
+    }
+    // L1.6: Clarity Interview
+    let gaps = detectClarityGaps(raw, l1.taskType, l1.confidence, projectContext);
+    // Effective model-driven interview: if a clarificationProposer (the actual task model) is provided,
+    // let the *model* itself generate the questions based on the user request + CLI enrichment so far.
+    // The model decides what it still needs and is missing from the enrich suggestions.
+    // Always generate model gaps when proposer wired (even if no handler for non-interactive resolve).
+    // This ensures model BE recs drive [Discovery] Intent/Outcome/Scope for native meta prompts.
+    // Handler only decides whether to show interactive askcard.
+    if (clarificationProposer) {
+        try {
+            const additionalContext = [
+                projectContext.language ? `Language: ${projectContext.language}` : "",
+                projectContext.framework ? `Framework: ${projectContext.framework}` : "",
+                projectContext.packageManager ? `Package manager: ${projectContext.packageManager}` : "",
+                projectContext.relevantModules?.length
+                    ? `Relevant modules: ${projectContext.relevantModules.map((m) => m.path).join(", ")}`
+                    : "",
+                projectContext.boundedContexts?.length
+                    ? `Bounded contexts: ${projectContext.boundedContexts.map((b) => `${b.name} (${b.path})`).join(", ")}`
+                    : "",
+                projectContext.eePatterns?.length ? `EE patterns: ${projectContext.eePatterns.slice(0, 3).join(" | ")}` : "",
+                recentTurnsSummary ? `\nRecent Conversation History:\n${recentTurnsSummary}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n");
+            const modelQuestions = await clarificationProposer({
+                raw,
+                l1: { taskType: l1.taskType, confidence: l1.confidence },
+                additionalContext: additionalContext || undefined,
+            });
+            if (modelQuestions.length > 0) {
+                gaps = modelQuestions.slice(0, 3).map((line, idx) => {
+                    let q = line;
+                    let recs = ["I will provide my own details / constraints"];
+                    const m = line.match(/\[MODEL RECS:?\s*(.+?)\]/i) || line.match(/RECS:\s*(.+)$/i);
+                    if (m) {
+                        recs = m[1]
+                            .split(/\s*\|\s*/)
+                            .map((r) => r.trim())
+                            .filter(Boolean)
+                            .slice(0, 3);
+                        q = line
+                            .replace(/\[MODEL RECS:?.*?\]/i, "")
+                            .replace(/RECS:.*$/, "")
+                            .trim();
+                    }
+                    return {
+                        dimension: "outcome",
+                        description: `Model-generated clarification #${idx + 1}`,
+                        suggestedQuestion: q || "What else needs clarification?",
+                        options: [...recs, "Other (type free answer)"],
+                        defaultIndex: 0,
+                    };
+                });
+            }
+        }
+        catch {
+            // fall through to static
+        }
+    }
+    if (!clarificationProposer && (l1.taskType === "analyze" || l1.taskType === "debug") && gaps.length > 0) {
+        // Fallback open question (non-model path)
+        gaps = [
+            {
+                dimension: "outcome",
+                description: "Specific outcome and constraints the agent/model needs from the user",
+                suggestedQuestion: `Để tôi (agent/model) thực hiện chính xác và có được thông tin cần thiết cho task này, bạn hãy cho tôi biết: kết quả mong muốn cụ thể, các ràng buộc quan trọng, hoặc bất kỳ chi tiết nào khác mà tôi cần làm rõ trước khi bắt đầu?`,
+                options: ["Tôi sẽ trả lời tự do / cung cấp chi tiết cần thiết"],
+                defaultIndex: 0,
+            },
+        ];
+    }
+    let clarifiedIntent;
+    let interviewed = false;
+    if (gaps.length > 0 && handler) {
+        interviewed = true;
+        const answeredGaps = gaps.map((g) => ({
+            ...g,
+            answer: null,
+        }));
+        const maxQ = Math.min(gaps.length, getMaxInterviewQuestions());
+        for (let i = 0; i < maxQ; i++) {
+            const gap = answeredGaps[i];
+            const question = buildInterviewQuestion(gap, randomUUID());
+            const answer = await handler.askQuestion(question);
+            answeredGaps[i] = { ...gap, answer: answer.text };
+        }
+        clarifiedIntent = buildClarifiedIntentFromAnswers(answeredGaps, raw, projectContext);
+    }
+    else {
+        clarifiedIntent = resolveGapsNonInteractive(gaps, projectContext, raw);
+    }
+    // Auto-fill outcome for analyze/plan/documentation when no outcome gap was asked
+    // Broaden to override bad generics (Local path, In prompts/..., project root literals) that
+    // can leak from detectClarityGaps/resolve when raw contains directory mentions or for native meta.
+    const autoOutcome = getAutofilledOutcome(l1.taskType, raw);
+    if (autoOutcome &&
+        (!clarifiedIntent.outcome ||
+            clarifiedIntent.outcome.startsWith("Complete the task") ||
+            /Local path|In prompts|directory as|project root|\/|absolute|local\/repo/i.test(clarifiedIntent.outcome) ||
+            clarifiedIntent.outcome.includes("/"))) {
+        clarifiedIntent = { ...clarifiedIntent, outcome: autoOutcome };
+    }
+    // L1.7: Feasibility Check
+    let feasibility = await checkFeasibility(clarifiedIntent, projectContext).catch(() => ({
+        viable: true,
+        warnings: [],
+        adjustedScope: clarifiedIntent.scope,
+    }));
+    // L1.8: User Acceptance
+    const intentStatement = `${l1.taskType ?? "task"}: ${clarifiedIntent.outcome}`;
+    let accepted = true;
+    if (handler && interviewed) {
+        const card = buildAcceptanceCard(intentStatement, clarifiedIntent, feasibility, raw);
+        const question = buildAcceptanceQuestion(card, randomUUID());
+        const answer = await handler.askQuestion(question);
+        const decision = answer.text.toLowerCase();
+        if (decision === "cancel") {
+            accepted = false;
+        }
+        else if (decision === "adjust") {
+            // Re-run interview once — but ONLY for gaps where the user's prior
+            // freetext answer was empty, identical to the raw prompt itself, or
+            // a continuation phrase. Re-asking gaps the user already answered
+            // (with non-trivial text) just produces duplicate askcards (evidence:
+            // session 1f29e238a816 — user picked "adjust", re-interview fired the
+            // same "Which part of codebase?" question they had just answered).
+            const reGaps = detectClarityGaps(raw, l1.taskType, l1.confidence, projectContext);
+            const priorAnswers = new Map((clarifiedIntent.gaps ?? []).map((g) => [g.dimension, g.answer ?? null]));
+            const reAnswered = reGaps.map((g) => ({
+                ...g,
+                answer: priorAnswers.get(g.dimension) ?? null,
+            }));
+            const maxRe = Math.min(reGaps.length, getMaxInterviewQuestions());
+            for (let i = 0; i < maxRe; i++) {
+                const gap = reAnswered[i];
+                const prior = gap.answer?.trim() ?? "";
+                const isTrivialPriorAnswer = prior === "" || prior.toLowerCase() === raw.trim().toLowerCase() || isLikelyFollowUp(prior);
+                if (!isTrivialPriorAnswer) {
+                    // User already gave a substantive answer for this gap. Keep it.
+                    continue;
+                }
+                const q = buildInterviewQuestion(gap, randomUUID());
+                const ans = await handler.askQuestion(q);
+                reAnswered[i] = { ...gap, answer: ans.text };
+            }
+            clarifiedIntent = buildClarifiedIntentFromAnswers(reAnswered, raw, projectContext);
+            feasibility = await checkFeasibility(clarifiedIntent, projectContext).catch(() => feasibility);
+            accepted = true;
+        }
+    }
+    if (accepted) {
+        markDiscoveryAccepted(sessionId);
+    }
+    return {
+        raw,
+        projectContext,
+        clarifiedIntent,
+        feasibility,
+        interviewed,
+        intentStatement,
+        outcome: clarifiedIntent.outcome,
+        scope: (feasibility.adjustedScope ?? []).length > 0
+            ? (feasibility.adjustedScope ?? [])
+            : (clarifiedIntent.scope ?? ["project root"]),
+        feasibilityWarnings: feasibility.warnings ?? [],
+        accepted,
+        taskType: l1.taskType,
+        confidence: l1.confidence,
+        domain: l1.domain,
+        outputStyle: l1.outputStyle,
+        discoveryMs: Date.now() - start,
+    };
+}
+function buildClarifiedIntentFromAnswers(answeredGaps, raw, projectContext) {
+    const outcomeGap = answeredGaps.find((g) => g.dimension === "outcome");
+    const scopeGap = answeredGaps.find((g) => g.dimension === "scope");
+    const constraintGap = answeredGaps.find((g) => g.dimension === "constraint");
+    const outcome = outcomeGap?.answer ?? `Complete: ${raw.slice(0, 80)}`;
+    const scope = (() => {
+        if (scopeGap?.answer)
+            return [scopeGap.answer.replace(/\s*\(.*\)\s*$/, "").trim()];
+        return projectContext.relevantModules.map((m) => m.path);
+    })();
+    const constraints = constraintGap?.answer ? [constraintGap.answer] : [];
+    return {
+        intentStatement: outcome,
+        outcome,
+        scope: scope.length > 0 ? scope : ["project root"],
+        feasibilityWarnings: [],
+        interviewed: false,
+        accepted: false,
+        constraints,
+        gaps: answeredGaps.map((g) => ({
+            dimension: g.dimension,
+            description: "",
+            suggestedQuestion: "",
+            options: g.options,
+            defaultIndex: g.defaultIndex,
+            answer: g.answer,
+        })),
+    };
+}
+/**
+ * Create a ModelClarificationProposer backed by the actual task model.
+ * The model receives the user raw + CLI enrichment (l1, project modules, etc.)
+ * and outputs the specific questions *it* needs the user to answer.
+ * This is the effective way to let the model interview based on what is still missing.
+ */
+export function createModelClarificationProposer(providerFactory, modelId) {
+    return async (input) => {
+        try {
+            const { resolveModelRuntime } = await import("../providers/runtime.js");
+            const { generateText } = await import("ai");
+            const runtime = resolveModelRuntime(providerFactory, modelId);
+            const contextStr = input.additionalContext
+                ? `\nCurrent CLI enrichment / context (use this to decide what is already known):\n${input.additionalContext}`
+                : "";
+            const special = isMetaAnalysisPrompt(input.raw)
+                ? `\nIf the request is a self-evaluation, meta-analysis or review of the CLI by the agent running inside it, do NOT ask about repo path, current directory, absolute path, local repo location or "which directory". Scope is always the full project root. Focus questions and recommends on which CLI internals (PIL, discovery, tools, compaction, EE, model BE, loop guard) to evaluate or specific improvements to assess after fixes. Use the enrichment context.`
+                : "";
+            const prompt = `You are the AI agent executing inside muonroi-cli.
+User request: "${input.raw}"
+Task type from CLI: ${input.l1.taskType}
+${contextStr}
+
+Based on the above, output 1-3 specific, concise questions you (the model) still need the user to answer right now so you have all the information required to complete the task accurately, without guessing.
+If the User request is a follow-up or continuation of the recent conversation history (if provided above), do NOT ask for new project details; assume the context is already established and return an empty array [] unless there is a critical new ambiguity.
+Consider the provided language/framework/modules/EE patterns when suggesting questions and recs — only ask what is missing from this context.${special}
+For each question also provide 1-2 short concrete recommendations the user can pick from (model-backed choices).
+Return ONLY valid JSON array, nothing else:
+[{"question":"...","recommends":["rec1","rec2"]}, ...]
+Max 3 items.`;
+            const result = await generateText({
+                model: runtime.model,
+                prompt,
+                maxOutputTokens: 256,
+            });
+            let items = [];
+            try {
+                const txt = result.text
+                    .trim()
+                    .replace(/```json|```/g, "")
+                    .trim();
+                items = JSON.parse(txt);
+            }
+            catch {
+                // degrade: treat whole text as one question with no recs
+                items = [{ question: result.text.trim(), recommends: [] }];
+            }
+            return items.slice(0, 3).map((it) => {
+                const recs = (it.recommends || []).slice(0, 2).join(" | ");
+                const tag = recs ? ` [MODEL RECS: ${recs}]` : "";
+                return `${it.question || "Clarify needed details"}${tag}`;
+            });
+        }
+        catch (err) {
+            // Silent degrade: no model questions, fall back to static
+            return [];
+        }
+    };
+}
+//# sourceMappingURL=discovery.js.map

package/dist/src/pil/index.d.ts

@@ -4,8 +4,10 @@
  * Public re-export surface for the Prompt Intelligence Layer (PIL) module.
  */
 export { DEFAULT_TOKEN_BUDGET, truncateToBudget } from "./budget.js";
+export { isDiscoveryEnabled } from "./config.js";
+export type { AcceptanceCardData, DiscoveryInteractionHandler, DiscoveryResult, ProjectContext, } from "./discovery-types.js";
 export { applyPilSuffix, getResponseToolSet } from "./layer6-output.js";
 export { type PipelineOptions, runPipeline } from "./pipeline.js";
-export { getResponseTaskType, isResponseTool } from "./response-tools.js";
+export { getResponseTaskType, isResponseTool, shouldHaltOnResponseTool, stepEmittedResponseTool, } from "./response-tools.js";
 export { getPilLastResult, setPilLastResult } from "./store.js";
 export type { LayerResult, OutputStyle, PipelineContext, PipelineMetrics, TaskType } from "./types.js";

package/dist/src/pil/index.js

@@ -4,8 +4,9 @@
  * Public re-export surface for the Prompt Intelligence Layer (PIL) module.
  */
 export { DEFAULT_TOKEN_BUDGET, truncateToBudget } from "./budget.js";
+export { isDiscoveryEnabled } from "./config.js";
 export { applyPilSuffix, getResponseToolSet } from "./layer6-output.js";
 export { runPipeline } from "./pipeline.js";
-export { getResponseTaskType, isResponseTool } from "./response-tools.js";
+export { getResponseTaskType, isResponseTool, shouldHaltOnResponseTool, stepEmittedResponseTool, } from "./response-tools.js";
 export { getPilLastResult, setPilLastResult } from "./store.js";
 //# sourceMappingURL=index.js.map

package/dist/src/pil/layer1-intent.d.ts

@@ -9,6 +9,7 @@
  * outputStyle is always null from Layer 1 — Layer 6 handles output style detection via bridge.
  * Fail-open: any error returns ctx unchanged with applied=false.
  */
+import type { LlmClassifyFn } from "./llm-classify.js";
 import type { PipelineContext } from "./types.js";
 export interface ComplexityInput {
     rawText: string;
@@ -46,4 +47,39 @@ export declare function scoreSufficiency(input: SufficiencyInput): SufficiencyOu
  * Returns a bucketed label and the raw score so callers can log both.
  */
 export declare function scoreComplexity(input: ComplexityInput): ComplexityOutput;
-export declare function layer1Intent(ctx: PipelineContext): Promise<PipelineContext>;
+/** Detect prompts asking to WRITE/ADD test cases — these are 'generate', not 'analyze'. */
+export declare function isTestGenerationTask(raw: string): boolean;
+/** Detect optimization-verb prompts where refactor is the correct taskType. */
+export declare function isPerformanceRefactor(raw: string): boolean;
+/** Detect short continuation prompts ("tiếp tục", "ok", "continue", …). */
+export declare function isContinuationPhrase(raw: string): boolean;
+/**
+ * True when the prompt is a conversational STATUS/META question about work
+ * already discussed (not a fresh task request). Guarded: short prompts only,
+ * and never when an explicit tool/command intent is present (those must keep
+ * the toolset). See the regex comment above for the originating session.
+ */
+export declare function isStatusCheckQuestion(raw: string): boolean;
+export interface Layer1Options {
+    /** Pass 4 LLM fallback closure — fires when brain returned null or confidence < 0.7. */
+    llmFallback?: LlmClassifyFn;
+}
+/**
+ * True when the prompt is an explicit request to RUN a command / use a shell
+ * tool. Used to veto a chitchat classification so the toolset is preserved.
+ */
+export declare function hasActionableToolIntent(raw: string): boolean;
+/**
+ * True when the prompt is a PURE social pleasantry (greeting / thanks / ack /
+ * farewell) — even when it is longer than the 2-word hot-path that Pass 2.5
+ * catches. Used to classify such turns as chitchat so message-processor can
+ * drop the ~15-20K tool-schema tax (a thank-you never needs bash/read_file/MCP).
+ *
+ * STRICT by construction: EVERY whitespace token must be social CORE or FILLER
+ * vocabulary, and at least one must be CORE. Any task/tool/file token (not in
+ * the whitelist) makes it false, so it can never swallow a real request — the
+ * bias is keep-tools. Live leak: "cảm ơn bạn rất nhiều nhé" (session
+ * 40c726a31a37) paid toolCount=37 because the old gate required ≤10 chars.
+ */
+export declare function isSocialPleasantry(raw: string): boolean;
+export declare function layer1Intent(ctx: PipelineContext, opts?: Layer1Options): Promise<PipelineContext>;