@code-insights/cli 3.6.0 → 4.0.0

package/server-dist/llm/prompt-constants.d.ts

@@ -0,0 +1,9 @@
+export declare const FRICTION_CLASSIFICATION_GUIDANCE = "\nFRICTION CLASSIFICATION GUIDANCE:\n\nEach friction point captures WHAT went wrong (category + description), WHO contributed (attribution), and WHY you classified it that way (_reasoning).\n\nCATEGORIES \u2014 classify the TYPE of gap or obstacle:\n- \"wrong-approach\": A strategy was pursued that didn't fit the task \u2014 wrong architecture, wrong tool, wrong pattern\n- \"knowledge-gap\": Incorrect knowledge was applied about a library, API, framework, or language feature\n- \"stale-assumptions\": Work proceeded from assumptions about current state that were incorrect (stale files, changed config, different environment)\n- \"incomplete-requirements\": Instructions were missing critical context, constraints, or acceptance criteria\n- \"context-loss\": Prior decisions or constraints established earlier in the session were lost or forgotten\n- \"scope-creep\": Work expanded beyond the boundaries of the stated task\n- \"repeated-mistakes\": The same or similar error occurred multiple times despite earlier correction\n- \"documentation-gap\": Relevant docs existed but were inaccessible or unfindable during the session\n- \"tooling-limitation\": The tool genuinely lacked a needed capability\n\nWhen no category fits, create a specific kebab-case category. A precise novel category is better than a vague canonical one.\n\nATTRIBUTION \u2014 3-step decision tree (follow IN ORDER):\nStep 1: Is the cause external to the user-AI interaction? (missing docs, broken tooling, infra outage) \u2192 \"environmental\"\nStep 2: Could the USER have prevented this with better input? Evidence: vague prompt, missing context, no constraints, late requirements, ambiguous correction \u2192 \"user-actionable\"\nStep 3: User input was clear and the AI still failed \u2192 \"ai-capability\"\nWhen genuinely mixed between user-actionable and ai-capability, lean \"user-actionable\" \u2014 this tool helps users improve.\n\nDESCRIPTION RULES:\n- One neutral sentence describing the GAP, not the actor\n- Include specific details (file names, APIs, error messages)\n- Frame as \"Missing X caused Y\" NOT \"The AI failed to X\" or \"The user forgot to X\"\n- Let the attribution field carry the who";
+export declare const CANONICAL_FRICTION_CATEGORIES: readonly ["wrong-approach", "knowledge-gap", "stale-assumptions", "incomplete-requirements", "context-loss", "scope-creep", "repeated-mistakes", "documentation-gap", "tooling-limitation"];
+export declare const CANONICAL_PATTERN_CATEGORIES: readonly ["structured-planning", "incremental-implementation", "verification-workflow", "systematic-debugging", "self-correction", "context-gathering", "domain-expertise", "effective-tooling"];
+export declare const CANONICAL_PQ_DEFICIT_CATEGORIES: readonly ["vague-request", "missing-context", "late-constraint", "unclear-correction", "scope-drift", "missing-acceptance-criteria", "assumption-not-surfaced"];
+export declare const CANONICAL_PQ_STRENGTH_CATEGORIES: readonly ["precise-request", "effective-context", "productive-correction"];
+export declare const CANONICAL_PQ_CATEGORIES: readonly ["vague-request", "missing-context", "late-constraint", "unclear-correction", "scope-drift", "missing-acceptance-criteria", "assumption-not-surfaced", "precise-request", "effective-context", "productive-correction"];
+export declare const PROMPT_QUALITY_CLASSIFICATION_GUIDANCE = "\nPROMPT QUALITY CLASSIFICATION GUIDANCE:\n\nEach finding captures a specific moment where the user's prompting either caused friction (deficit) or enabled productivity (strength).\n\nDEFICIT CATEGORIES \u2014 classify prompting problems:\n- \"vague-request\": Request lacked specificity needed for the AI to act without guessing. Missing file paths, function names, expected behavior, or concrete details.\n  NOT this category if the AI had enough context to succeed but failed anyway \u2014 that is an AI capability issue, not a prompting issue.\n\n- \"missing-context\": Critical background knowledge about architecture, conventions, dependencies, or current state was not provided.\n  NOT this category if the information was available in the codebase and the AI could have found it by reading files \u2014 that is an AI context-gathering failure.\n\n- \"late-constraint\": A requirement or constraint was provided AFTER the AI had already started implementing a different approach, causing rework.\n  NOT this category if the constraint was genuinely discovered during implementation (requirements changed). Only classify if the user KNEW the constraint before the session started.\n\n- \"unclear-correction\": The user told the AI its output was wrong without explaining what was wrong or why. \"That's not right\", \"try again\", \"no\" without context.\n  NOT this category if the user gave a brief but sufficient correction (\"use map instead of forEach\" is clear enough).\n\n- \"scope-drift\": The session objective shifted mid-conversation, or multiple unrelated objectives were addressed in one session.\n  NOT this category if the user is working through logically connected subtasks of one objective.\n\n- \"missing-acceptance-criteria\": The user did not define what successful completion looks like, leading to back-and-forth about whether the output meets expectations.\n  NOT this category for exploratory sessions where the user is discovering what they want.\n\n- \"assumption-not-surfaced\": The user held an unstated assumption that the AI could not reasonably infer from code or conversation.\n  NOT this category if the assumption was reasonable for the AI to make (e.g., standard coding conventions).\n\nSTRENGTH CATEGORIES \u2014 classify prompting successes (only when notably above average):\n- \"precise-request\": Request included enough specificity (file paths, function names, expected behavior, error messages) that the AI could act correctly on the first attempt.\n\n- \"effective-context\": User proactively shared architecture, conventions, prior decisions, or current state that the AI demonstrably used to make better decisions.\n\n- \"productive-correction\": When the AI went off track, the user provided a correction that included WHAT was wrong, WHY, and enough context for the AI to redirect effectively on the next response.\n\nCONTRASTIVE PAIRS:\n- vague-request vs missing-context: Was the problem in HOW THE TASK WAS DESCRIBED (vague-request) or WHAT BACKGROUND KNOWLEDGE WAS ABSENT (missing-context)?\n- late-constraint vs missing-context: Did the user EVENTUALLY provide it in the same session? Yes \u2192 late-constraint. Never \u2192 missing-context.\n- missing-context vs assumption-not-surfaced: Is this a FACT the user could have copy-pasted (missing-context), or a BELIEF/PREFERENCE they held (assumption-not-surfaced)?\n- scope-drift vs missing-acceptance-criteria: Did the user try to do TOO MANY THINGS (scope-drift) or ONE THING WITHOUT DEFINING SUCCESS (missing-acceptance-criteria)?\n- unclear-correction vs vague-request: Was this the user's FIRST MESSAGE about this task (vague-request) or a RESPONSE TO AI OUTPUT (unclear-correction)?\n\nDIMENSION SCORING (0-100):\n- context_provision: How well did the user provide relevant background upfront?\n  90+: Proactively shared architecture, constraints, conventions. 50-69: Notable gaps causing detours. <30: No context, AI working blind.\n- request_specificity: How precise were task requests?\n  90+: File paths, expected behavior, scope boundaries. 50-69: Mix of specific and vague. <30: Nearly all requests lacked detail.\n- scope_management: How focused was the session?\n  90+: Single clear objective, logical progression. 50-69: Some drift but primary goal met. <30: Unfocused, no clear objective.\n- information_timing: Were requirements provided when needed?\n  90+: All constraints front-loaded before implementation. 50-69: Some important requirements late. <30: Requirements drip-fed, constant corrections.\n- correction_quality: How well did the user redirect the AI?\n  90+: Corrections included what, why, and context. 50-69: Mix of clear and unclear. <30: Corrections gave almost no signal.\n  Score 75 if no corrections were needed (absence of corrections in a successful session = good prompting).\n\nEDGE CASES:\n- Short sessions (<5 user messages): Score conservatively. Do not penalize for missing elements unnecessary in quick tasks.\n- Exploration sessions: Do not penalize for missing acceptance criteria or scope drift.\n- Sessions where AI performed well despite vague prompts: Still classify deficits. Impact should be \"low\" since no visible cost.\n- Agentic/delegation sessions: If the user gave a clear high-level directive and the AI autonomously planned and executed successfully, do not penalize for low message count or lack of micro-level specificity. Effective delegation IS good prompting. Focus on the quality of the initial delegation prompt.";
+export declare const EFFECTIVE_PATTERN_CLASSIFICATION_GUIDANCE = "\nEFFECTIVE PATTERN CLASSIFICATION GUIDANCE:\n\nEach effective pattern captures a technique or approach that contributed to a productive session outcome.\n\nBASELINE EXCLUSION \u2014 do NOT classify these as patterns:\n- Routine file reads at session start (Read/Glob/Grep on <5 files before editing)\n- Following explicit user instructions (user said \"run tests\" \u2192 running tests is not a pattern)\n- Basic tool usage (single file edits, standard CLI commands)\n- Trivial self-corrections (typo fixes, minor syntax errors caught immediately)\nOnly classify behavior that is NOTABLY thorough, strategic, or beyond baseline expectations.\n\nCATEGORIES \u2014 classify the TYPE of effective pattern:\n- \"structured-planning\": Decomposed the task into explicit steps, defined scope boundaries, or established a plan BEFORE writing code. Signal: plan/task-list/scope-definition appears before implementation.\n- \"incremental-implementation\": Work progressed in small, verifiable steps with validation between them. Signal: multiple small edits with checks between, not one large batch.\n- \"verification-workflow\": Proactive correctness checks (builds, tests, linters, types) BEFORE considering work complete. Signal: test/build/lint commands when nothing was known broken.\n- \"systematic-debugging\": Methodical investigation using structured techniques (binary search, log insertion, reproduction isolation). Signal: multiple targeted diagnostic steps, not random guessing.\n- \"self-correction\": Recognized a wrong path and pivoted WITHOUT user correction. Signal: explicit acknowledgment of mistake + approach change. NOT this if the user pointed out the error.\n- \"context-gathering\": NOTABLY thorough investigation before changes \u2014 reading 5+ files, cross-module exploration, schema/type/config review. Signal: substantial Read/Grep/Glob usage spanning multiple directories before any Edit/Write.\n- \"domain-expertise\": Applied specific framework/API/language knowledge correctly on first attempt without searching. Signal: correct non-obvious API usage with no preceding search and no subsequent error. NOT this if files were read first \u2014 that is context-gathering.\n- \"effective-tooling\": Leveraged advanced tool capabilities that multiplied productivity \u2014 agent delegation, parallel work, multi-file coordination, strategic mode selection. Signal: use of tool features beyond basic read/write/edit.\n\nCONTRASTIVE PAIRS:\n- structured-planning vs incremental-implementation: Planning = DECIDING what to do (before). Incremental = HOW you execute (during). Can have one without the other.\n- context-gathering vs domain-expertise: Gathering = ACTIVE INVESTIGATION (reading files). Expertise = APPLYING EXISTING KNOWLEDGE without investigation. If files were read first \u2192 context-gathering.\n- verification-workflow vs systematic-debugging: Verification = PROACTIVE (checking working code). Debugging = REACTIVE (investigating a failure).\n- self-correction vs user-directed: Self-correction = AI caught own mistake unprompted. User said \"that's wrong\" \u2192 NOT self-correction.\n\nDRIVER \u2014 4-step decision tree (follow IN ORDER):\nStep 1: Did user infrastructure enable this? (CLAUDE.md rules, agent configs, hookify hooks, custom commands, system prompts) \u2192 \"user-driven\"\nStep 2: Did the user explicitly request this behavior? (asked for plan, requested tests, directed investigation) \u2192 \"user-driven\"\nStep 3: Did the AI exhibit this without any user prompting or infrastructure? \u2192 \"ai-driven\"\nStep 4: Both made distinct, identifiable contributions \u2192 \"collaborative\"\nUse \"collaborative\" ONLY when you can name what EACH party contributed. If uncertain, prefer the more specific label.\n\nWhen no canonical category fits, create a specific kebab-case category (a precise novel category is better than forcing a poor fit).";
+//# sourceMappingURL=prompt-constants.d.ts.map

package/server-dist/llm/prompt-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-constants.d.ts","sourceRoot":"","sources":["../../src/llm/prompt-constants.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,gCAAgC,wpEA4BH,CAAC;AAE3C,eAAO,MAAM,6BAA6B,6LAUhC,CAAC;AAEX,eAAO,MAAM,4BAA4B,kMAS/B,CAAC;AAEX,eAAO,MAAM,+BAA+B,iKAQlC,CAAC;AAEX,eAAO,MAAM,gCAAgC,4EAInC,CAAC;AAEX,eAAO,MAAM,uBAAuB,kOAG1B,CAAC;AAEX,eAAO,MAAM,sCAAsC,03KA0D8P,CAAC;AAElT,eAAO,MAAM,yCAAyC,u0HAmC+E,CAAC"}

package/server-dist/llm/prompt-constants.js

@@ -0,0 +1,169 @@
+// Canonical category arrays and classification guidance strings for LLM analysis.
+// Extracted from prompts.ts — imported by normalizers and prompt generators.
+// Shared guidance for friction category and attribution classification.
+// Actor-neutral category definitions describe the gap, not the actor.
+// Attribution field captures who contributed to the friction for actionability.
+export const FRICTION_CLASSIFICATION_GUIDANCE = `
+FRICTION CLASSIFICATION GUIDANCE:
+
+Each friction point captures WHAT went wrong (category + description), WHO contributed (attribution), and WHY you classified it that way (_reasoning).
+
+CATEGORIES — classify the TYPE of gap or obstacle:
+- "wrong-approach": A strategy was pursued that didn't fit the task — wrong architecture, wrong tool, wrong pattern
+- "knowledge-gap": Incorrect knowledge was applied about a library, API, framework, or language feature
+- "stale-assumptions": Work proceeded from assumptions about current state that were incorrect (stale files, changed config, different environment)
+- "incomplete-requirements": Instructions were missing critical context, constraints, or acceptance criteria
+- "context-loss": Prior decisions or constraints established earlier in the session were lost or forgotten
+- "scope-creep": Work expanded beyond the boundaries of the stated task
+- "repeated-mistakes": The same or similar error occurred multiple times despite earlier correction
+- "documentation-gap": Relevant docs existed but were inaccessible or unfindable during the session
+- "tooling-limitation": The tool genuinely lacked a needed capability
+
+When no category fits, create a specific kebab-case category. A precise novel category is better than a vague canonical one.
+
+ATTRIBUTION — 3-step decision tree (follow IN ORDER):
+Step 1: Is the cause external to the user-AI interaction? (missing docs, broken tooling, infra outage) → "environmental"
+Step 2: Could the USER have prevented this with better input? Evidence: vague prompt, missing context, no constraints, late requirements, ambiguous correction → "user-actionable"
+Step 3: User input was clear and the AI still failed → "ai-capability"
+When genuinely mixed between user-actionable and ai-capability, lean "user-actionable" — this tool helps users improve.
+
+DESCRIPTION RULES:
+- One neutral sentence describing the GAP, not the actor
+- Include specific details (file names, APIs, error messages)
+- Frame as "Missing X caused Y" NOT "The AI failed to X" or "The user forgot to X"
+- Let the attribution field carry the who`;
+export const CANONICAL_FRICTION_CATEGORIES = [
+    'wrong-approach',
+    'knowledge-gap',
+    'stale-assumptions',
+    'incomplete-requirements',
+    'context-loss',
+    'scope-creep',
+    'repeated-mistakes',
+    'documentation-gap',
+    'tooling-limitation',
+];
+export const CANONICAL_PATTERN_CATEGORIES = [
+    'structured-planning',
+    'incremental-implementation',
+    'verification-workflow',
+    'systematic-debugging',
+    'self-correction',
+    'context-gathering',
+    'domain-expertise',
+    'effective-tooling',
+];
+export const CANONICAL_PQ_DEFICIT_CATEGORIES = [
+    'vague-request',
+    'missing-context',
+    'late-constraint',
+    'unclear-correction',
+    'scope-drift',
+    'missing-acceptance-criteria',
+    'assumption-not-surfaced',
+];
+export const CANONICAL_PQ_STRENGTH_CATEGORIES = [
+    'precise-request',
+    'effective-context',
+    'productive-correction',
+];
+export const CANONICAL_PQ_CATEGORIES = [
+    ...CANONICAL_PQ_DEFICIT_CATEGORIES,
+    ...CANONICAL_PQ_STRENGTH_CATEGORIES,
+];
+export const PROMPT_QUALITY_CLASSIFICATION_GUIDANCE = `
+PROMPT QUALITY CLASSIFICATION GUIDANCE:
+
+Each finding captures a specific moment where the user's prompting either caused friction (deficit) or enabled productivity (strength).
+
+DEFICIT CATEGORIES — classify prompting problems:
+- "vague-request": Request lacked specificity needed for the AI to act without guessing. Missing file paths, function names, expected behavior, or concrete details.
+  NOT this category if the AI had enough context to succeed but failed anyway — that is an AI capability issue, not a prompting issue.
+
+- "missing-context": Critical background knowledge about architecture, conventions, dependencies, or current state was not provided.
+  NOT this category if the information was available in the codebase and the AI could have found it by reading files — that is an AI context-gathering failure.
+
+- "late-constraint": A requirement or constraint was provided AFTER the AI had already started implementing a different approach, causing rework.
+  NOT this category if the constraint was genuinely discovered during implementation (requirements changed). Only classify if the user KNEW the constraint before the session started.
+
+- "unclear-correction": The user told the AI its output was wrong without explaining what was wrong or why. "That's not right", "try again", "no" without context.
+  NOT this category if the user gave a brief but sufficient correction ("use map instead of forEach" is clear enough).
+
+- "scope-drift": The session objective shifted mid-conversation, or multiple unrelated objectives were addressed in one session.
+  NOT this category if the user is working through logically connected subtasks of one objective.
+
+- "missing-acceptance-criteria": The user did not define what successful completion looks like, leading to back-and-forth about whether the output meets expectations.
+  NOT this category for exploratory sessions where the user is discovering what they want.
+
+- "assumption-not-surfaced": The user held an unstated assumption that the AI could not reasonably infer from code or conversation.
+  NOT this category if the assumption was reasonable for the AI to make (e.g., standard coding conventions).
+
+STRENGTH CATEGORIES — classify prompting successes (only when notably above average):
+- "precise-request": Request included enough specificity (file paths, function names, expected behavior, error messages) that the AI could act correctly on the first attempt.
+
+- "effective-context": User proactively shared architecture, conventions, prior decisions, or current state that the AI demonstrably used to make better decisions.
+
+- "productive-correction": When the AI went off track, the user provided a correction that included WHAT was wrong, WHY, and enough context for the AI to redirect effectively on the next response.
+
+CONTRASTIVE PAIRS:
+- vague-request vs missing-context: Was the problem in HOW THE TASK WAS DESCRIBED (vague-request) or WHAT BACKGROUND KNOWLEDGE WAS ABSENT (missing-context)?
+- late-constraint vs missing-context: Did the user EVENTUALLY provide it in the same session? Yes → late-constraint. Never → missing-context.
+- missing-context vs assumption-not-surfaced: Is this a FACT the user could have copy-pasted (missing-context), or a BELIEF/PREFERENCE they held (assumption-not-surfaced)?
+- scope-drift vs missing-acceptance-criteria: Did the user try to do TOO MANY THINGS (scope-drift) or ONE THING WITHOUT DEFINING SUCCESS (missing-acceptance-criteria)?
+- unclear-correction vs vague-request: Was this the user's FIRST MESSAGE about this task (vague-request) or a RESPONSE TO AI OUTPUT (unclear-correction)?
+
+DIMENSION SCORING (0-100):
+- context_provision: How well did the user provide relevant background upfront?
+  90+: Proactively shared architecture, constraints, conventions. 50-69: Notable gaps causing detours. <30: No context, AI working blind.
+- request_specificity: How precise were task requests?
+  90+: File paths, expected behavior, scope boundaries. 50-69: Mix of specific and vague. <30: Nearly all requests lacked detail.
+- scope_management: How focused was the session?
+  90+: Single clear objective, logical progression. 50-69: Some drift but primary goal met. <30: Unfocused, no clear objective.
+- information_timing: Were requirements provided when needed?
+  90+: All constraints front-loaded before implementation. 50-69: Some important requirements late. <30: Requirements drip-fed, constant corrections.
+- correction_quality: How well did the user redirect the AI?
+  90+: Corrections included what, why, and context. 50-69: Mix of clear and unclear. <30: Corrections gave almost no signal.
+  Score 75 if no corrections were needed (absence of corrections in a successful session = good prompting).
+
+EDGE CASES:
+- Short sessions (<5 user messages): Score conservatively. Do not penalize for missing elements unnecessary in quick tasks.
+- Exploration sessions: Do not penalize for missing acceptance criteria or scope drift.
+- Sessions where AI performed well despite vague prompts: Still classify deficits. Impact should be "low" since no visible cost.
+- Agentic/delegation sessions: If the user gave a clear high-level directive and the AI autonomously planned and executed successfully, do not penalize for low message count or lack of micro-level specificity. Effective delegation IS good prompting. Focus on the quality of the initial delegation prompt.`;
+export const EFFECTIVE_PATTERN_CLASSIFICATION_GUIDANCE = `
+EFFECTIVE PATTERN CLASSIFICATION GUIDANCE:
+
+Each effective pattern captures a technique or approach that contributed to a productive session outcome.
+
+BASELINE EXCLUSION — do NOT classify these as patterns:
+- Routine file reads at session start (Read/Glob/Grep on <5 files before editing)
+- Following explicit user instructions (user said "run tests" → running tests is not a pattern)
+- Basic tool usage (single file edits, standard CLI commands)
+- Trivial self-corrections (typo fixes, minor syntax errors caught immediately)
+Only classify behavior that is NOTABLY thorough, strategic, or beyond baseline expectations.
+
+CATEGORIES — classify the TYPE of effective pattern:
+- "structured-planning": Decomposed the task into explicit steps, defined scope boundaries, or established a plan BEFORE writing code. Signal: plan/task-list/scope-definition appears before implementation.
+- "incremental-implementation": Work progressed in small, verifiable steps with validation between them. Signal: multiple small edits with checks between, not one large batch.
+- "verification-workflow": Proactive correctness checks (builds, tests, linters, types) BEFORE considering work complete. Signal: test/build/lint commands when nothing was known broken.
+- "systematic-debugging": Methodical investigation using structured techniques (binary search, log insertion, reproduction isolation). Signal: multiple targeted diagnostic steps, not random guessing.
+- "self-correction": Recognized a wrong path and pivoted WITHOUT user correction. Signal: explicit acknowledgment of mistake + approach change. NOT this if the user pointed out the error.
+- "context-gathering": NOTABLY thorough investigation before changes — reading 5+ files, cross-module exploration, schema/type/config review. Signal: substantial Read/Grep/Glob usage spanning multiple directories before any Edit/Write.
+- "domain-expertise": Applied specific framework/API/language knowledge correctly on first attempt without searching. Signal: correct non-obvious API usage with no preceding search and no subsequent error. NOT this if files were read first — that is context-gathering.
+- "effective-tooling": Leveraged advanced tool capabilities that multiplied productivity — agent delegation, parallel work, multi-file coordination, strategic mode selection. Signal: use of tool features beyond basic read/write/edit.
+
+CONTRASTIVE PAIRS:
+- structured-planning vs incremental-implementation: Planning = DECIDING what to do (before). Incremental = HOW you execute (during). Can have one without the other.
+- context-gathering vs domain-expertise: Gathering = ACTIVE INVESTIGATION (reading files). Expertise = APPLYING EXISTING KNOWLEDGE without investigation. If files were read first → context-gathering.
+- verification-workflow vs systematic-debugging: Verification = PROACTIVE (checking working code). Debugging = REACTIVE (investigating a failure).
+- self-correction vs user-directed: Self-correction = AI caught own mistake unprompted. User said "that's wrong" → NOT self-correction.
+
+DRIVER — 4-step decision tree (follow IN ORDER):
+Step 1: Did user infrastructure enable this? (CLAUDE.md rules, agent configs, hookify hooks, custom commands, system prompts) → "user-driven"
+Step 2: Did the user explicitly request this behavior? (asked for plan, requested tests, directed investigation) → "user-driven"
+Step 3: Did the AI exhibit this without any user prompting or infrastructure? → "ai-driven"
+Step 4: Both made distinct, identifiable contributions → "collaborative"
+Use "collaborative" ONLY when you can name what EACH party contributed. If uncertain, prefer the more specific label.
+
+When no canonical category fits, create a specific kebab-case category (a precise novel category is better than forcing a poor fit).`;
+//# sourceMappingURL=prompt-constants.js.map

package/server-dist/llm/prompt-constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-constants.js","sourceRoot":"","sources":["../../src/llm/prompt-constants.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,6EAA6E;AAE7E,wEAAwE;AACxE,sEAAsE;AACtE,gFAAgF;AAChF,MAAM,CAAC,MAAM,gCAAgC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CA4BN,CAAC;AAE3C,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,gBAAgB;IAChB,eAAe;IACf,mBAAmB;IACnB,yBAAyB;IACzB,cAAc;IACd,aAAa;IACb,mBAAmB;IACnB,mBAAmB;IACnB,oBAAoB;CACZ,CAAC;AAEX,MAAM,CAAC,MAAM,4BAA4B,GAAG;IAC1C,qBAAqB;IACrB,4BAA4B;IAC5B,uBAAuB;IACvB,sBAAsB;IACtB,iBAAiB;IACjB,mBAAmB;IACnB,kBAAkB;IAClB,mBAAmB;CACX,CAAC;AAEX,MAAM,CAAC,MAAM,+BAA+B,GAAG;IAC7C,eAAe;IACf,iBAAiB;IACjB,iBAAiB;IACjB,oBAAoB;IACpB,aAAa;IACb,6BAA6B;IAC7B,yBAAyB;CACjB,CAAC;AAEX,MAAM,CAAC,MAAM,gCAAgC,GAAG;IAC9C,iBAAiB;IACjB,mBAAmB;IACnB,uBAAuB;CACf,CAAC;AAEX,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,GAAG,+BAA+B;IAClC,GAAG,gCAAgC;CAC3B,CAAC;AAEX,MAAM,CAAC,MAAM,sCAAsC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iTA0D2P,CAAC;AAElT,MAAM,CAAC,MAAM,yCAAyC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qIAmC4E,CAAC"}

package/server-dist/llm/prompt-quality-analysis.d.ts

@@ -0,0 +1,8 @@
+import type { SQLiteMessageRow } from './prompt-types.js';
+import { type SessionData } from './analysis-db.js';
+import { type AnalysisOptions, type AnalysisResult } from './analysis-internal.js';
+/**
+ * Analyze prompt quality for a session.
+ */
+export declare function analyzePromptQuality(session: SessionData, messages: SQLiteMessageRow[], options?: AnalysisOptions): Promise<AnalysisResult>;
+//# sourceMappingURL=prompt-quality-analysis.d.ts.map

package/server-dist/llm/prompt-quality-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-quality-analysis.d.ts","sourceRoot":"","sources":["../../src/llm/prompt-quality-analysis.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAI1D,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAsC,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEvH;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,gBAAgB,EAAE,EAC5B,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,cAAc,CAAC,CAmIzB"}

package/server-dist/llm/prompt-quality-analysis.js

@@ -0,0 +1,133 @@
+// Prompt quality analysis — isolated from the main session analysis pipeline.
+// Extracted from analysis.ts to keep each analysis type in its own focused module.
+import { createLLMClient, isLLMConfigured, loadLLMConfig } from './client.js';
+import { calculateAnalysisCost } from './analysis-pricing.js';
+import { saveAnalysisUsage } from './analysis-usage-db.js';
+import { formatMessagesForAnalysis, classifyStoredUserMessage } from './message-format.js';
+import { parsePromptQualityResponse } from './response-parsers.js';
+import { SHARED_ANALYST_SYSTEM_PROMPT, buildCacheableConversationBlock, buildPromptQualityInstructions } from './prompts.js';
+import { convertPromptQualityToInsightRow, saveInsightsToDb, deleteSessionInsights, } from './analysis-db.js';
+import { MAX_INPUT_TOKENS, buildSessionMeta } from './analysis-internal.js';
+/**
+ * Analyze prompt quality for a session.
+ */
+export async function analyzePromptQuality(session, messages, options) {
+    if (!isLLMConfigured()) {
+        return {
+            success: false,
+            insights: [],
+            error: 'LLM not configured. Run `code-insights config llm` to configure a provider.',
+        };
+    }
+    if (messages.length === 0) {
+        return {
+            success: false,
+            insights: [],
+            error: 'No messages found for this session.',
+        };
+    }
+    // Change 2: Filter to genuine human messages only (not tool-results or system artifacts).
+    // Pre-change: a session with 1 human + 50 tool-result rows passed the gate incorrectly.
+    // This prevented wasted LLM calls on sessions where there is nothing to evaluate.
+    const humanMessages = messages.filter(m => m.type === 'user' && classifyStoredUserMessage(m.content) === 'human');
+    if (humanMessages.length < 2) {
+        return {
+            success: false,
+            insights: [],
+            error: 'Not enough user messages to analyze prompt quality (need at least 2).',
+        };
+    }
+    try {
+        const startTime = Date.now();
+        const client = createLLMClient();
+        const formattedMessages = formatMessagesForAnalysis(messages);
+        let analysisInput = formattedMessages;
+        const estimatedTokens = client.estimateTokens(formattedMessages);
+        if (estimatedTokens > MAX_INPUT_TOKENS) {
+            const targetLength = Math.floor((MAX_INPUT_TOKENS / estimatedTokens) * formattedMessages.length * 0.8);
+            analysisInput = formattedMessages.slice(0, targetLength) + '\n\n[... conversation truncated for analysis ...]';
+        }
+        // Change 3: Pass structured session shape instead of raw message count.
+        // "Total messages: 51" misled the LLM when 43 of those were tool-result rows.
+        const assistantMessages = messages.filter(m => m.type === 'assistant');
+        const toolExchangeCount = messages.length - humanMessages.length - assistantMessages.length;
+        const sessionMeta = buildSessionMeta(session);
+        const sessionShape = {
+            humanMessageCount: humanMessages.length,
+            assistantMessageCount: assistantMessages.length,
+            toolExchangeCount,
+        };
+        options?.onProgress?.({ phase: 'analyzing' });
+        const response = await client.chat([
+            { role: 'system', content: SHARED_ANALYST_SYSTEM_PROMPT },
+            { role: 'user', content: [
+                    buildCacheableConversationBlock(analysisInput),
+                    { type: 'text', text: buildPromptQualityInstructions(session.project_name, sessionShape, sessionMeta) },
+                ] },
+        ], { signal: options?.signal });
+        const parsed = parsePromptQualityResponse(response.content);
+        if (!parsed.success) {
+            return {
+                success: false,
+                insights: [],
+                error: 'Failed to parse prompt quality analysis. Please try again.',
+                error_type: parsed.error.error_type,
+                response_length: parsed.error.response_length,
+                response_preview: parsed.error.response_preview,
+            };
+        }
+        options?.onProgress?.({ phase: 'saving' });
+        const insight = convertPromptQualityToInsightRow(parsed.data, session);
+        // Save new insight, then delete old prompt_quality insights
+        saveInsightsToDb([insight]);
+        deleteSessionInsights(session.id, {
+            includeOnlyTypes: ['prompt_quality'],
+            excludeIds: [insight.id],
+        });
+        // Record analysis cost to analysis_usage table (V7).
+        const llmConfig = loadLLMConfig();
+        if (llmConfig && response.usage) {
+            const costUsd = calculateAnalysisCost(llmConfig.provider, llmConfig.model, {
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                cacheCreationTokens: response.usage.cacheCreationTokens,
+                cacheReadTokens: response.usage.cacheReadTokens,
+            });
+            saveAnalysisUsage({
+                session_id: session.id,
+                analysis_type: 'prompt_quality',
+                provider: llmConfig.provider,
+                model: llmConfig.model,
+                input_tokens: response.usage.inputTokens,
+                output_tokens: response.usage.outputTokens,
+                cache_creation_tokens: response.usage.cacheCreationTokens,
+                cache_read_tokens: response.usage.cacheReadTokens,
+                estimated_cost_usd: costUsd,
+                duration_ms: Date.now() - startTime,
+                chunk_count: 1,
+            });
+        }
+        return {
+            success: true,
+            insights: [insight],
+            usage: response.usage ? {
+                inputTokens: response.usage.inputTokens,
+                outputTokens: response.usage.outputTokens,
+                ...(response.usage.cacheCreationTokens !== undefined && { cacheCreationTokens: response.usage.cacheCreationTokens }),
+                ...(response.usage.cacheReadTokens !== undefined && { cacheReadTokens: response.usage.cacheReadTokens }),
+            } : undefined,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return { success: false, insights: [], error: 'Analysis cancelled', error_type: 'abort' };
+        }
+        return {
+            success: false,
+            insights: [],
+            error: error instanceof Error ? error.message : 'Prompt quality analysis failed',
+            error_type: 'api_error',
+        };
+    }
+}
+//# sourceMappingURL=prompt-quality-analysis.js.map

package/server-dist/llm/prompt-quality-analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-quality-analysis.js","sourceRoot":"","sources":["../../src/llm/prompt-quality-analysis.ts"],"names":[],"mappings":"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"}

package/server-dist/llm/prompt-quality-normalize.d.ts

@@ -0,0 +1,26 @@
+export declare const PQ_CATEGORY_LABELS: Record<string, string>;
+/**
+ * Normalize a prompt quality category to the closest canonical category.
+ * Returns the original category if no close match is found.
+ *
+ * Matching rules (in order):
+ * 1. Exact match against canonical list → return as-is
+ * 1.5. Explicit alias match → return alias target (may be non-canonical)
+ * 2. Levenshtein distance <= 2 → return canonical match
+ * 3. Substring match (category contains canonical or vice versa) → return canonical
+ * 4. No match → return original (novel category)
+ *
+ * Note: alias targets in PQ_ALIASES bypass the canonical check intentionally.
+ */
+export declare function normalizePromptQualityCategory(category: string): string;
+/**
+ * Get a human-readable label for a prompt quality category.
+ * Falls back to Title Case conversion for novel categories.
+ */
+export declare function getPQCategoryLabel(category: string): string;
+/**
+ * Get the type (deficit or strength) for a prompt quality category.
+ * Novel categories default to deficit.
+ */
+export declare function getPQCategoryType(category: string): 'deficit' | 'strength';
+//# sourceMappingURL=prompt-quality-normalize.d.ts.map

package/server-dist/llm/prompt-quality-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-quality-normalize.d.ts","sourceRoot":"","sources":["../../src/llm/prompt-quality-normalize.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAWrD,CAAC;AA6EF;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKvE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,CAE1E"}

package/server-dist/llm/prompt-quality-normalize.js

@@ -0,0 +1,116 @@
+// Prompt quality category normalization.
+// Clusters similar free-form categories to canonical ones during aggregation.
+// Delegates to normalize-utils.ts for the shared levenshtein/normalizeCategory algorithm.
+import { CANONICAL_PQ_CATEGORIES, CANONICAL_PQ_STRENGTH_CATEGORIES } from './prompt-constants.js';
+import { normalizeCategory, kebabToTitleCase } from './normalize-utils.js';
+// Human-readable labels for each canonical category.
+export const PQ_CATEGORY_LABELS = {
+    'vague-request': 'Vague Request',
+    'missing-context': 'Missing Context',
+    'late-constraint': 'Late Constraint',
+    'unclear-correction': 'Unclear Correction',
+    'scope-drift': 'Scope Drift',
+    'missing-acceptance-criteria': 'Missing Acceptance Criteria',
+    'assumption-not-surfaced': 'Assumption Not Surfaced',
+    'precise-request': 'Precise Request',
+    'effective-context': 'Effective Context',
+    'productive-correction': 'Productive Correction',
+};
+const STRENGTH_SET = new Set(CANONICAL_PQ_STRENGTH_CATEGORIES);
+// Explicit alias map for clustering emergent category variants.
+// Targets don't need to be in CANONICAL_PQ_CATEGORIES —
+// this clusters semantically-equivalent novel categories together.
+// Alias lookup runs AFTER exact canonical match but BEFORE Levenshtein,
+// so well-known emergent variants are clustered deterministically.
+const PQ_ALIASES = {
+    // vague-request variants
+    'vague-instructions': 'vague-request',
+    'unclear-request': 'vague-request',
+    'imprecise-prompting': 'vague-request',
+    'ambiguous-request': 'vague-request',
+    'incomplete-request': 'vague-request',
+    'generic-request': 'vague-request',
+    // missing-context variants
+    'missing-information': 'missing-context',
+    'insufficient-context': 'missing-context',
+    'no-context': 'missing-context',
+    'lack-of-context': 'missing-context',
+    'missing-background': 'missing-context',
+    // late-constraint variants
+    'late-context': 'late-constraint',
+    'late-requirements': 'late-constraint',
+    'piecemeal-requirements': 'late-constraint',
+    'drip-fed-requirements': 'late-constraint',
+    'incremental-requirements': 'late-constraint',
+    'late-specification': 'late-constraint',
+    // unclear-correction variants
+    'unclear-feedback': 'unclear-correction',
+    'vague-correction': 'unclear-correction',
+    'unhelpful-correction': 'unclear-correction',
+    'vague-feedback': 'unclear-correction',
+    // scope-drift variants
+    'context-drift': 'scope-drift',
+    'objective-bloat': 'scope-drift',
+    'session-bloat': 'scope-drift',
+    'topic-switching': 'scope-drift',
+    'scope-creep': 'scope-drift',
+    // missing-acceptance-criteria variants
+    'no-acceptance-criteria': 'missing-acceptance-criteria',
+    'undefined-done': 'missing-acceptance-criteria',
+    'no-definition-of-done': 'missing-acceptance-criteria',
+    'unclear-success-criteria': 'missing-acceptance-criteria',
+    // assumption-not-surfaced variants
+    'hidden-assumption': 'assumption-not-surfaced',
+    'unstated-assumption': 'assumption-not-surfaced',
+    'implicit-assumption': 'assumption-not-surfaced',
+    'unspoken-expectation': 'assumption-not-surfaced',
+    // precise-request variants (strengths)
+    'clear-request': 'precise-request',
+    'specific-request': 'precise-request',
+    'well-specified-request': 'precise-request',
+    'detailed-request': 'precise-request',
+    // effective-context variants (strengths)
+    'good-context': 'effective-context',
+    'upfront-context': 'effective-context',
+    'proactive-context': 'effective-context',
+    'rich-context': 'effective-context',
+    // productive-correction variants (strengths)
+    'clear-correction': 'productive-correction',
+    'effective-feedback': 'productive-correction',
+    'helpful-correction': 'productive-correction',
+    'constructive-feedback': 'productive-correction',
+};
+/**
+ * Normalize a prompt quality category to the closest canonical category.
+ * Returns the original category if no close match is found.
+ *
+ * Matching rules (in order):
+ * 1. Exact match against canonical list → return as-is
+ * 1.5. Explicit alias match → return alias target (may be non-canonical)
+ * 2. Levenshtein distance <= 2 → return canonical match
+ * 3. Substring match (category contains canonical or vice versa) → return canonical
+ * 4. No match → return original (novel category)
+ *
+ * Note: alias targets in PQ_ALIASES bypass the canonical check intentionally.
+ */
+export function normalizePromptQualityCategory(category) {
+    return normalizeCategory(category, {
+        canonicalCategories: CANONICAL_PQ_CATEGORIES,
+        aliases: PQ_ALIASES,
+    });
+}
+/**
+ * Get a human-readable label for a prompt quality category.
+ * Falls back to Title Case conversion for novel categories.
+ */
+export function getPQCategoryLabel(category) {
+    return PQ_CATEGORY_LABELS[category] ?? kebabToTitleCase(category);
+}
+/**
+ * Get the type (deficit or strength) for a prompt quality category.
+ * Novel categories default to deficit.
+ */
+export function getPQCategoryType(category) {
+    return STRENGTH_SET.has(category) ? 'strength' : 'deficit';
+}
+//# sourceMappingURL=prompt-quality-normalize.js.map

package/server-dist/llm/prompt-quality-normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-quality-normalize.js","sourceRoot":"","sources":["../../src/llm/prompt-quality-normalize.ts"],"names":[],"mappings":"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"}