sift-light 1.0.0

package/src/mcp-model-output.ts

@@ -0,0 +1,120 @@
+import type { AnalysisDetails } from "./analysis-types.js";
+import type { SiftLightDetails, SiftLightResult } from "./types.js";
+
+import { formatStatistics } from "./result-statistics.js";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function compactMetadata(details: SiftLightDetails, analysis: AnalysisDetails): string[] {
+  return [
+    ...(analysis.statistics ? formatStatistics(analysis.statistics) : []),
+    analysis.counts ? `Counts: ${JSON.stringify(analysis.counts)}` : undefined,
+    analysis.termCounts ? `Term counts: ${JSON.stringify(analysis.termCounts)}` : undefined,
+    analysis.termCountsNextRequest
+      ? `More term counts: ${JSON.stringify(analysis.termCountsNextRequest)}`
+      : undefined,
+    analysis.matchesRequest
+      ? `Matches request: ${JSON.stringify(analysis.matchesRequest)}`
+      : undefined,
+    analysis.changes ? `Changes: ${JSON.stringify(analysis.changes)}` : undefined,
+    analysis.scope ? `Scope: ${JSON.stringify(analysis.scope)}` : undefined,
+    analysis.chunks ? `Chunks: ${JSON.stringify(analysis.chunks)}` : undefined,
+    analysis.coverage ? `Coverage: ${JSON.stringify(analysis.coverage)}` : undefined,
+    analysis.stats ? `Stats: ${JSON.stringify(analysis.stats)}` : undefined,
+    analysis.sourceGeneration
+      ? `Source generation: ${JSON.stringify(analysis.sourceGeneration)}`
+      : undefined,
+    analysis.semanticJudge
+      ? `Semantic judge: ${JSON.stringify(analysis.semanticJudge)}`
+      : undefined,
+    details.operation ? `Operation: ${JSON.stringify(details.operation)}` : undefined,
+    analysis.kind === "outline" && analysis.modelOutput
+      ? "[Outline signatures are deferred; use version-checked inspection for source excerpts.]"
+      : undefined,
+    ...analysis.reasons.map((reason) => `[${reason}]`),
+    details.redactionApplied ? "[Display redaction applied.]" : undefined,
+  ].filter((line): line is string => line !== undefined);
+}
+
+function compactRows(analysis: AnalysisDetails): string[] {
+  const rows: string[] = [];
+  let previousPath: string | undefined;
+  for (const item of analysis.items) {
+    if (item.path !== previousPath) {
+      rows.push(JSON.stringify(item.path));
+      previousPath = item.path;
+    }
+    const label = analysis.kind === "outline" && analysis.modelOutput ? item.label : "metadata";
+    const semanticJudge = item.details?.semanticJudge;
+    const judgment =
+      isRecord(semanticJudge) &&
+      typeof semanticJudge.classification === "string" &&
+      typeof semanticJudge.probability === "number" &&
+      typeof semanticJudge.model === "string"
+        ? ` Jev: ${semanticJudge.classification}; probability=${String(semanticJudge.probability)};${typeof semanticJudge.confidence === "number" ? ` confidence=${String(semanticJudge.confidence)};` : ""} model=${JSON.stringify(semanticJudge.model)}.`
+        : "";
+    rows.push(`#${String(item.index)} L${String(item.line)} ${label}${judgment}`);
+  }
+  return rows;
+}
+
+function compactInspectInstruction(analysis: AnalysisDetails): string | undefined {
+  if (analysis.inspectCursor)
+    return `Inspect item #N: mode="inspect", cursor=${JSON.stringify(analysis.inspectCursor)}, matchIndex=N.`;
+  const inspect = analysis.items.find((item) => item.inspect !== undefined)?.inspect;
+  if (!inspect || typeof inspect.cursor !== "string") return undefined;
+  return `Inspect item #N: mode="inspect", cursor=${JSON.stringify(inspect.cursor)}, matchIndex=N${inspect.redact ? ", redact=true" : ""}.`;
+}
+
+function compactHeader(details: SiftLightDetails, analysis: AnalysisDetails): string {
+  if (
+    analysis.termCounts &&
+    analysis.termCountsOffset !== undefined &&
+    analysis.totalTerms !== undefined
+  ) {
+    const start = analysis.termCountsOffset + 1;
+    const end = analysis.termCountsOffset + analysis.termCounts.length;
+    return `${analysis.kind} term inventory ${String(start)}–${String(end)} of ${String(analysis.totalTerms)} (${details.status}).`;
+  }
+  const first = analysis.items[0]?.index;
+  const last = analysis.items.at(-1)?.index;
+  const shown =
+    first === undefined || last === undefined
+      ? "showing none"
+      : `showing #${String(first)}–#${String(last)}`;
+  return `${analysis.kind}: ${String(analysis.totalItems)} retained ${analysis.unit} (${details.status}); ${shown}.`;
+}
+
+function distinctNextRequest(
+  details: SiftLightDetails,
+  analysis: AnalysisDetails,
+): string | undefined {
+  if (!details.nextRequest) return undefined;
+  const serialized = JSON.stringify(details.nextRequest);
+  return serialized === JSON.stringify(analysis.termCountsNextRequest) ||
+    serialized === JSON.stringify(analysis.matchesRequest)
+    ? undefined
+    : serialized;
+}
+
+export function compactMcpModelText(result: SiftLightResult): string {
+  const analysis = result.details.analysis;
+  // Validation is a source-state report, not a pageable syntax/result inventory.
+  // Its authoritative text retains freshness, comparison target and check interval.
+  if (!analysis || analysis.kind === "validate") return result.text;
+  const header = compactHeader(result.details, analysis);
+  const inspect = compactInspectInstruction(analysis);
+  const nextRequest = distinctNextRequest(result.details, analysis);
+  const compact = [
+    header,
+    ...compactMetadata(result.details, analysis),
+    ...compactRows(analysis),
+    ...(inspect ? [inspect] : []),
+    ...(nextRequest ? [`Next request: ${nextRequest}`] : []),
+  ].join("\n");
+  const standard = result.text.replace(" Structured output retains per-item evidence details.", "");
+  if (analysis.semanticJudge) return compact;
+  return Buffer.byteLength(compact) < Buffer.byteLength(standard) ? compact : standard;
+}

package/src/mcp-output.ts

@@ -0,0 +1,9 @@
+export const DEFAULT_MCP_OUTPUT_MODE = "structured";
+
+export type SiftLightMcpOutputMode = "structured" | "text" | "model";
+
+export function parseSiftLightMcpOutputMode(value: string | undefined): SiftLightMcpOutputMode {
+  if (value === undefined || value === DEFAULT_MCP_OUTPUT_MODE) return DEFAULT_MCP_OUTPUT_MODE;
+  if (value === "text" || value === "model") return value;
+  throw new Error('SIFT_LIGHT_MCP_OUTPUT_MODE must be "structured", "text", or "model"');
+}

package/src/mcp-semantic-judge.ts

@@ -0,0 +1,39 @@
+import {
+  DEFAULT_SEMANTIC_JUDGE_CONFIG,
+  readSiftLightConfigFile,
+  SIFT_LIGHT_CONFIG_ENV,
+} from "./config-reader.js";
+import {
+  createDisabledSemanticJudgeIntegration,
+  createSemanticJudgeIntegration,
+  type SemanticJudgeIntegration,
+} from "./semantic-judge.js";
+
+function configuredPath(environment: NodeJS.ProcessEnv): string | undefined {
+  const value = environment[SIFT_LIGHT_CONFIG_ENV]?.trim();
+  return value || undefined;
+}
+
+/**
+ * Resolve the MCP-only opt-in without borrowing a host-specific Pi/OMP path.
+ * The MCP process must receive the same config path explicitly in its own host
+ * environment; an absent path remains an observable, local-only disabled state.
+ */
+export async function createMcpSemanticJudgeIntegration(
+  environment: NodeJS.ProcessEnv = process.env,
+): Promise<SemanticJudgeIntegration> {
+  const path = configuredPath(environment);
+  if (!path) return createDisabledSemanticJudgeIntegration(DEFAULT_SEMANTIC_JUDGE_CONFIG);
+
+  const config = await readSiftLightConfigFile(path, { missing: "error" });
+  return createSemanticJudgeIntegration(
+    config.semanticJudge ?? DEFAULT_SEMANTIC_JUDGE_CONFIG,
+    environment,
+  );
+}
+
+export function mcpSemanticJudgeConfigSource(
+  environment: NodeJS.ProcessEnv = process.env,
+): "explicit-config" | "not-configured" {
+  return configuredPath(environment) ? "explicit-config" : "not-configured";
+}