pi-lens 3.8.21 → 3.8.23

package/clients/dispatch/facts/function-facts.ts

@@ -0,0 +1,177 @@
+import * as ts from "typescript";
+import type { FactProvider } from "../fact-provider-types.js";
+
+const BOUNDARY_PREFIXES = [
+  "fetch",
+  "fs.",
+  "db.",
+  "http",
+  "axios",
+  "got",
+  "req.",
+  "res.",
+];
+
+export interface FunctionSummary {
+  name: string;
+  line: number;
+  column: number;
+  isAsync: boolean;
+  hasAwait: boolean;
+  hasReturnAwaitCall: boolean;
+  statementCount: number;
+  parameterCount: number;
+  isPassThroughWrapper: boolean;
+  passThroughTarget?: string;
+  isBoundaryWrapper: boolean;
+}
+
+function getFunctionName(node: ts.Node): string {
+  if (ts.isFunctionDeclaration(node)) {
+    return node.name?.text ?? "<anonymous>";
+  }
+  if (ts.isMethodDeclaration(node)) {
+    if (ts.isIdentifier(node.name)) return node.name.text;
+    return node.name.getText();
+  }
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+      return parent.name.text;
+    }
+    if (ts.isPropertyAssignment(parent)) {
+      return parent.name.getText();
+    }
+    return "<anonymous>";
+  }
+  return "<unknown>";
+}
+
+function isCallPassThrough(
+  stmt: ts.Statement,
+  paramNames: string[],
+): { pass: boolean; target?: string } {
+  if (!ts.isReturnStatement(stmt) || !stmt.expression) return { pass: false };
+  const expr = stmt.expression;
+  if (!ts.isCallExpression(expr)) return { pass: false };
+
+  const args = expr.arguments.map((a) => a.getText());
+  if (args.length !== paramNames.length) return { pass: false };
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] !== paramNames[i]) return { pass: false };
+  }
+
+  return { pass: true, target: expr.expression.getText() };
+}
+
+function hasAwaitInNode(node: ts.Node): boolean {
+  let found = false;
+  const walk = (n: ts.Node): void => {
+    if (found) return;
+    if (ts.isAwaitExpression(n)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(n, walk);
+  };
+  walk(node);
+  return found;
+}
+
+function hasReturnAwaitCall(node: ts.Node): boolean {
+  let found = false;
+  const walk = (n: ts.Node): void => {
+    if (found) return;
+    if (
+      ts.isReturnStatement(n) &&
+      n.expression &&
+      ts.isAwaitExpression(n.expression) &&
+      ts.isCallExpression(n.expression.expression)
+    ) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(n, walk);
+  };
+  walk(node);
+  return found;
+}
+
+export const functionFactProvider: FactProvider = {
+  id: "fact.file.functions",
+  provides: ["file.functionSummaries"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  run(ctx, store) {
+    const content = store.getFileFact<string>(ctx.filePath, "file.content");
+    if (!content) {
+      store.setFileFact(ctx.filePath, "file.functionSummaries", []);
+      return;
+    }
+
+    const sourceFile = ts.createSourceFile(
+      ctx.filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TSX,
+    );
+
+    const summaries: FunctionSummary[] = [];
+
+    const addSummary = (
+      node:
+        | ts.FunctionDeclaration
+        | ts.MethodDeclaration
+        | ts.FunctionExpression
+        | ts.ArrowFunction,
+    ): void => {
+      const body = node.body;
+      if (!body || !ts.isBlock(body)) return;
+
+      const lc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+      const paramNames = node.parameters.map((p) => p.name.getText(sourceFile));
+      const statementCount = body.statements.length;
+      const passThrough =
+        statementCount === 1
+          ? isCallPassThrough(body.statements[0], paramNames)
+          : { pass: false as const };
+      const target = passThrough.target ?? "";
+      const lowerTarget = target.toLowerCase();
+      const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) =>
+        lowerTarget.startsWith(prefix),
+      );
+
+      summaries.push({
+        name: getFunctionName(node),
+        line: lc.line + 1,
+        column: lc.character + 1,
+        isAsync: !!node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword),
+        hasAwait: hasAwaitInNode(body),
+        hasReturnAwaitCall: hasReturnAwaitCall(body),
+        statementCount,
+        parameterCount: node.parameters.length,
+        isPassThroughWrapper: passThrough.pass,
+        passThroughTarget: passThrough.target,
+        isBoundaryWrapper,
+      });
+    };
+
+    const visit = (node: ts.Node): void => {
+      if (
+        ts.isFunctionDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node)
+      ) {
+        addSummary(node);
+      }
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    store.setFileFact(ctx.filePath, "file.functionSummaries", summaries);
+  },
+};

package/clients/dispatch/facts/try-catch-facts.ts

@@ -0,0 +1,80 @@
+import * as ts from "typescript";
+import type { FactProvider } from "../fact-provider-types.js";
+
+export interface TryCatchSummary {
+  line: number;
+  column: number;
+  catchParam: string | null;
+  bodyText: string;
+  isEmpty: boolean;
+  hasRethrow: boolean;
+  hasLogging: boolean;
+}
+
+function isOnlyWhitespaceOrComments(text: string): boolean {
+  // Remove block comments
+  let stripped = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  // Remove line comments
+  stripped = stripped.replace(/\/\/[^\n]*/g, "");
+  return stripped.trim().length === 0;
+}
+
+export const tryCatchFactProvider: FactProvider = {
+  id: "tryCatchFacts",
+  provides: ["file.tryCatchSummaries"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  run(ctx, store) {
+    const content = store.getFileFact<string>(ctx.filePath, "file.content");
+    if (!content) {
+      store.setFileFact(ctx.filePath, "file.tryCatchSummaries", []);
+      return;
+    }
+
+    const sourceFile = ts.createSourceFile(
+      ctx.filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TSX,
+    );
+
+    const summaries: TryCatchSummary[] = [];
+
+    function visit(node: ts.Node): void {
+      if (ts.isCatchClause(node)) {
+        const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const line = pos.line + 1;
+        const column = pos.character + 1;
+
+        let catchParam: string | null = null;
+        if (node.variableDeclaration) {
+          const name = node.variableDeclaration.name;
+          if (ts.isIdentifier(name)) {
+            catchParam = name.text;
+          }
+        }
+
+        const bodyText = node.block.getText(sourceFile)
+          .replace(/^\{/, "")
+          .replace(/\}$/, "")
+          .trim();
+
+        const isEmpty = isOnlyWhitespaceOrComments(bodyText);
+        const hasRethrow = /\bthrow\b/.test(bodyText);
+        const hasLogging =
+          /\bconsole\.(log|warn|error)\b/.test(bodyText) ||
+          /\blogger\./.test(bodyText);
+
+        summaries.push({ line, column, catchParam, bodyText, isEmpty, hasRethrow, hasLogging });
+      }
+
+      ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+    store.setFileFact(ctx.filePath, "file.tryCatchSummaries", summaries);
+  },
+};

package/clients/dispatch/integration.ts

@@ -11,21 +11,24 @@ import {
 	getLspCapableKinds,
 	getPrimaryDispatchGroup,
 } from "../language-policy.js";
+import {
+	formatSlopScoreSummary,
+	type SlopScoreSummary,
+} from "../session-summary.js";
+import { FactStore } from "./fact-store.js";
 import {
 	clearLatencyReports,
 	clearCoverageNoticeState,
-	createBaselineStore,
 	createDispatchContext,
+	RunnerRegistry,
 	type DispatchLatencyReport,
 	dispatchForFile,
 	formatLatencyReport,
 	getLatencyReports,
-	getRunnersForKind,
 	type RunnerLatency,
 } from "./dispatcher.js";
 import { TOOL_PLANS } from "./plan.js";
 import type {
-	BaselineStore,
 	DispatchResult,
 	ModifiedRange,
 	PiAgentAPI,
@@ -36,16 +39,114 @@ export type { DispatchLatencyReport, RunnerLatency };
 // Re-export latency tracking types and functions
 export { clearLatencyReports, formatLatencyReport, getLatencyReports };
 
-// Import runners to register them
-import "./runners/index.js";
+import { registerDefaultRunners } from "./runners/index.js";
+
+// Register fact providers
+import { registerProvider } from "./fact-runner.js";
+import { runProviders } from "./fact-runner.js";
+import { fileContentProvider } from "./facts/file-content.js";
+registerProvider(fileContentProvider);
+import { tryCatchFactProvider } from "./facts/try-catch-facts.js";
+registerProvider(tryCatchFactProvider);
+import { functionFactProvider } from "./facts/function-facts.js";
+registerProvider(functionFactProvider);
+import { commentFactProvider } from "./facts/comment-facts.js";
+registerProvider(commentFactProvider);
 
-// --- Persistent Baseline Store ---
-// Survives across dispatchLint calls within a session.
-// Without this, delta mode is a no-op: every call creates a fresh empty
-// store, so baselines.get() always returns undefined and every issue
-// looks "new" every time.
-const sessionBaselines: BaselineStore = createBaselineStore();
+// Register fact rules
+import { registerRule } from "./fact-rule-runner.js";
+import { errorObscuringRule } from "./rules/error-obscuring.js";
+import { errorSwallowingRule } from "./rules/error-swallowing.js";
+import { asyncNoiseRule } from "./rules/async-noise.js";
+import { passThroughWrappersRule } from "./rules/pass-through-wrappers.js";
+import { placeholderCommentsRule } from "./rules/placeholder-comments.js";
+registerRule(errorObscuringRule);
+registerRule(errorSwallowingRule);
+registerRule(asyncNoiseRule);
+registerRule(passThroughWrappersRule);
+registerRule(placeholderCommentsRule);
+
+const sessionFacts = new FactStore();
+const sessionRunnerRegistry = new RunnerRegistry();
+registerDefaultRunners(sessionRunnerRegistry);
 const LSP_CAPABLE_KINDS = new Set<FileKind>(getLspCapableKinds());
+const FACT_RULE_IDS = new Set([
+	"error-obscuring",
+	"error-swallowing",
+	"async-noise",
+	"pass-through-wrappers",
+	"placeholder-comments",
+]);
+const sessionSlopRuleCounts = new Map<string, number>();
+let sessionSlopDiagnosticCount = 0;
+let sessionWrittenLineCount = 0;
+
+function resetSessionSlopScore(): void {
+	sessionSlopRuleCounts.clear();
+	sessionSlopDiagnosticCount = 0;
+	sessionWrittenLineCount = 0;
+}
+
+function detectFactRuleId(diagnostic: {
+	id?: string;
+	rule?: string;
+	tool?: string;
+}): string | undefined {
+	if (diagnostic.rule && FACT_RULE_IDS.has(diagnostic.rule)) {
+		return diagnostic.rule;
+	}
+	if (diagnostic.tool && FACT_RULE_IDS.has(diagnostic.tool)) {
+		return diagnostic.tool;
+	}
+	if (diagnostic.id) {
+		const prefix = diagnostic.id.split(":", 1)[0];
+		if (FACT_RULE_IDS.has(prefix)) {
+			return prefix;
+		}
+	}
+	return undefined;
+}
+
+function trackSessionSlopStats(
+	ctx: ReturnType<typeof createDispatchContext>,
+	diagnostics: DispatchResult["diagnostics"],
+): void {
+	const lineCount = ctx.facts.getFileFact<number>(ctx.filePath, "file.lineCount");
+	if (typeof lineCount === "number" && Number.isFinite(lineCount) && lineCount > 0) {
+		sessionWrittenLineCount += lineCount;
+	}
+
+	for (const diagnostic of diagnostics) {
+		const ruleId = detectFactRuleId(diagnostic);
+		if (!ruleId) continue;
+		sessionSlopDiagnosticCount += 1;
+		sessionSlopRuleCounts.set(ruleId, (sessionSlopRuleCounts.get(ruleId) ?? 0) + 1);
+	}
+}
+
+export function getDispatchSlopScoreSummary(): SlopScoreSummary | undefined {
+	if (sessionSlopDiagnosticCount === 0 || sessionWrittenLineCount <= 0) {
+		return undefined;
+	}
+
+	const totalKlocWritten = sessionWrittenLineCount / 1000;
+	const ruleCounts = [...sessionSlopRuleCounts.entries()]
+		.map(([ruleId, count]) => ({ ruleId, count }))
+		.sort((a, b) => b.count - a.count || a.ruleId.localeCompare(b.ruleId));
+
+	return {
+		totalRuleDiagnostics: sessionSlopDiagnosticCount,
+		totalKlocWritten,
+		scorePerKloc: sessionSlopDiagnosticCount / totalKlocWritten,
+		ruleCounts,
+	};
+}
+
+export function getDispatchSlopScoreLine(): string {
+	const summary = getDispatchSlopScoreSummary();
+	if (!summary) return "";
+	return formatSlopScoreSummary(summary);
+}
 
 function withPrimaryPolicyGroup(
 	kind: keyof typeof TOOL_PLANS,
@@ -104,7 +205,8 @@ export function getDispatchGroupsForKind(
  * starts with a clean slate.
  */
 export function resetDispatchBaselines(): void {
-	sessionBaselines.clear();
+	sessionFacts.clearAll();
+	resetSessionSlopScore();
 	clearCoverageNoticeState();
 }
 
@@ -129,10 +231,11 @@ export async function dispatchLint(
 		filePath,
 		cwd,
 		pi,
-		sessionBaselines,
+		sessionFacts,
 		true,
 		modifiedRanges,
 	);
+	sessionFacts.clearFileFactsFor(ctx.filePath);
 
 	const kind = ctx.kind;
 	if (!kind) return "";
@@ -140,7 +243,9 @@ export async function dispatchLint(
 	const groups = getDispatchGroupsForKind(kind, pi);
 	if (groups.length === 0) return "";
 
-	const result = await dispatchForFile(ctx, groups);
+	await runProviders(ctx);
+	const result = await dispatchForFile(ctx, groups, sessionRunnerRegistry);
+	trackSessionSlopStats(ctx, result.diagnostics);
 	return result.output;
 }
 
@@ -157,10 +262,11 @@ export async function dispatchLintWithResult(
 		filePath,
 		cwd,
 		pi,
-		sessionBaselines,
+		sessionFacts,
 		true,
 		modifiedRanges,
 	);
+	sessionFacts.clearFileFactsFor(ctx.filePath);
 
 	const kind = ctx.kind;
 	if (!kind) {
@@ -190,14 +296,10 @@ export async function dispatchLintWithResult(
 		};
 	}
 
-	return dispatchForFile(ctx, groups);
-}
-
-/**
- * Create a baseline store for delta mode tracking
- */
-export function createLintBaselines() {
-	return createBaselineStore();
+	await runProviders(ctx);
+	const result = await dispatchForFile(ctx, groups, sessionRunnerRegistry);
+	trackSessionSlopStats(ctx, result.diagnostics);
+	return result;
 }
 
 /**
@@ -216,6 +318,10 @@ export async function getAvailableRunners(filePath: string): Promise<string[]> {
 	const kind = detectFileKind(filePath);
 	if (!kind) return [];
 
-	const runners = getRunnersForKind(kind);
+	const normalizedPath = filePath.replace(/\\/g, "/");
+	const pathForFilter = normalizedPath.startsWith("/")
+		? normalizedPath
+		: `/${normalizedPath}`;
+	const runners = sessionRunnerRegistry.getForKind(kind, pathForFilter);
 	return runners.map((r) => r.id);
 }

package/clients/dispatch/priorities.ts

@@ -0,0 +1,22 @@
+/**
+ * Dispatch runner priority tiers.
+ *
+ * NOTE: These priorities only govern ordering within dispatch runner execution.
+ * They do not represent full write/edit pipeline order.
+ */
+export const PRIORITY = {
+	LSP_PRIMARY: 4,
+	LSP_FALLBACK: 5,
+	FORMAT_AND_LINT_PRIMARY: 10,
+	LINT_SECONDARY: 12,
+	STRUCTURAL_ANALYSIS: 14,
+	SPECIALIZED_ANALYSIS: 15,
+	GENERAL_ANALYSIS: 20,
+	YAML_LINT: 22,
+	SQL_LINT: 24,
+	PYTHON_SLOP: 25,
+	DOC_QUALITY: 30,
+	SIMILARITY: 35,
+	ARCHITECTURE: 40,
+	DEEP_LANGUAGE_ANALYSIS: 50,
+} as const;

package/clients/dispatch/rules/async-noise.ts

@@ -0,0 +1,43 @@
+import { isTestFile } from "../../file-utils.js";
+import type { FactRule } from "../fact-provider-types.js";
+import type { FunctionSummary } from "../facts/function-facts.js";
+import type { Diagnostic } from "../types.js";
+
+export const asyncNoiseRule: FactRule = {
+  id: "async-noise",
+  requires: ["file.functionSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath) && !isTestFile(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact<FunctionSummary[]>(
+      ctx.filePath,
+      "file.functionSummaries",
+    );
+    if (!summaries) return [];
+
+    const diagnostics: Diagnostic[] = [];
+    for (const fn of summaries) {
+      if (
+        fn.isAsync &&
+        !fn.hasAwait &&
+        !fn.hasReturnAwaitCall &&
+        !fn.isPassThroughWrapper
+      ) {
+        diagnostics.push({
+          id: `async-noise:${ctx.filePath}:${fn.line}:${fn.column}`,
+          tool: "async-noise",
+          filePath: ctx.filePath,
+          line: fn.line,
+          column: fn.column,
+          severity: "warning",
+          semantic: "warning",
+          message: `Async function '${fn.name}' has no await and appears to add async noise`,
+          rule: "async-noise",
+        });
+      }
+    }
+
+    return diagnostics;
+  },
+};

package/clients/dispatch/rules/error-obscuring.ts

@@ -0,0 +1,40 @@
+import type { FactRule } from "../fact-provider-types.js";
+import type { Diagnostic } from "../types.js";
+import type { TryCatchSummary } from "../facts/try-catch-facts.js";
+
+export const errorObscuringRule: FactRule = {
+  id: "error-obscuring",
+  requires: ["file.tryCatchSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact<TryCatchSummary[]>(
+      ctx.filePath,
+      "file.tryCatchSummaries",
+    );
+    if (!summaries) return [];
+
+    const diagnostics: Diagnostic[] = [];
+    for (const s of summaries) {
+      if (
+        !s.isEmpty &&
+        !s.hasRethrow &&
+        s.catchParam !== null &&
+        !s.bodyText.includes(s.catchParam)
+      ) {
+        diagnostics.push({
+          id: `error-obscuring:${ctx.filePath}:${s.line}:${s.column}`,
+          tool: "error-obscuring",
+          filePath: ctx.filePath,
+          line: s.line,
+          column: s.column,
+          severity: "warning",
+          semantic: "warning",
+          message: `Catch block catches '${s.catchParam}' but never references it — the error is obscured`,
+        });
+      }
+    }
+    return diagnostics;
+  },
+};

package/clients/dispatch/rules/error-swallowing.ts

@@ -0,0 +1,35 @@
+import type { FactRule } from "../fact-provider-types.js";
+import type { Diagnostic } from "../types.js";
+import type { TryCatchSummary } from "../facts/try-catch-facts.js";
+
+export const errorSwallowingRule: FactRule = {
+  id: "error-swallowing",
+  requires: ["file.tryCatchSummaries"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact<TryCatchSummary[]>(
+      ctx.filePath,
+      "file.tryCatchSummaries",
+    );
+    if (!summaries) return [];
+
+    const diagnostics: Diagnostic[] = [];
+    for (const s of summaries) {
+      if (s.isEmpty) {
+        diagnostics.push({
+          id: `error-swallowing:${ctx.filePath}:${s.line}:${s.column}`,
+          tool: "error-swallowing",
+          filePath: ctx.filePath,
+          line: s.line,
+          column: s.column,
+          severity: "warning",
+          semantic: "warning",
+          message: `Empty catch block silently swallows errors`,
+        });
+      }
+    }
+    return diagnostics;
+  },
+};

package/clients/dispatch/rules/pass-through-wrappers.ts

@@ -0,0 +1,52 @@
+import { isTestFile } from "../../file-utils.js";
+import type { FactRule } from "../fact-provider-types.js";
+import type { CommentSummary } from "../facts/comment-facts.js";
+import type { FunctionSummary } from "../facts/function-facts.js";
+import type { Diagnostic } from "../types.js";
+
+const ALIAS_COMMENT_RE =
+  /\b(alias|backward\s*compat|backwards\s*compat|compatibility|shim|adapter)\b/i;
+
+function hasAliasCommentNear(line: number, comments: CommentSummary[]): boolean {
+  return comments.some(
+    (comment) => comment.line >= line - 2 && comment.line <= line && ALIAS_COMMENT_RE.test(comment.text),
+  );
+}
+
+export const passThroughWrappersRule: FactRule = {
+  id: "pass-through-wrappers",
+  requires: ["file.functionSummaries", "file.comments"],
+  appliesTo(ctx) {
+    return /\.tsx?$/.test(ctx.filePath) && !isTestFile(ctx.filePath);
+  },
+  evaluate(ctx, store) {
+    const summaries = store.getFileFact<FunctionSummary[]>(
+      ctx.filePath,
+      "file.functionSummaries",
+    );
+    const comments = store.getFileFact<CommentSummary[]>(ctx.filePath, "file.comments");
+    if (!summaries || !comments) return [];
+
+    const diagnostics: Diagnostic[] = [];
+    for (const fn of summaries) {
+      if (!fn.isPassThroughWrapper || fn.statementCount !== 1 || fn.isBoundaryWrapper) {
+        continue;
+      }
+      if (hasAliasCommentNear(fn.line, comments)) continue;
+
+      diagnostics.push({
+        id: `pass-through-wrapper:${ctx.filePath}:${fn.line}:${fn.column}`,
+        tool: "pass-through-wrappers",
+        filePath: ctx.filePath,
+        line: fn.line,
+        column: fn.column,
+        severity: "warning",
+        semantic: "warning",
+        rule: "pass-through-wrappers",
+        message: `Function '${fn.name}' is a trivial pass-through wrapper`,
+      });
+    }
+
+    return diagnostics;
+  },
+};