memorix 1.8.6 → 1.8.8

package/src/codegraph/scip-provider.ts

@@ -0,0 +1,181 @@
+import { isAbsolute, relative, resolve } from 'node:path';
+import { sanitizeCredentials } from '../memory/secret-filter.js';
+import { isCodeGraphExcludedPath } from './exclude.js';
+import { normalizeCodePath } from './ids.js';
+import type { CodeGraphOutline, ExternalCodeGraphRelation, ExternalCodeGraphSymbol } from './types.js';
+
+/**
+ * SCIP is intentionally an input boundary here, not a second persistence
+ * format. The normalized outline is bounded and remains separate from the
+ * canonical local CodeGraph tables.
+ */
+export interface ScipOutlineOptions {
+  projectRoot: string;
+  exclude?: string[];
+  maxNodes?: number;
+  maxEdges?: number;
+  maxFiles?: number;
+}
+
+const DEFAULT_MAX_NODES = 16;
+const DEFAULT_MAX_EDGES = 24;
+const DEFAULT_MAX_FILES = 12;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function text(value: unknown, max = 240): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const normalized = sanitizeCredentials(value).replace(/[\u0000-\u001f]/g, ' ').replace(/\s+/g, ' ').trim();
+  return normalized && normalized.length <= max ? normalized : undefined;
+}
+
+function safeRelativePath(projectRoot: string, value: unknown, exclude?: string[]): string | undefined {
+  const raw = text(value, 1_024);
+  if (!raw || isAbsolute(raw)) return undefined;
+  const absolute = resolve(projectRoot, raw);
+  const fromRoot = relative(resolve(projectRoot), absolute);
+  if (!fromRoot || fromRoot === '..' || fromRoot.startsWith('..\\') || fromRoot.startsWith('../') || isAbsolute(fromRoot)) return undefined;
+  const normalized = normalizeCodePath(fromRoot);
+  return isCodeGraphExcludedPath(normalized, exclude) ? undefined : normalized;
+}
+
+function integer(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+
+function lineFromRange(value: unknown): number | undefined {
+  if (!Array.isArray(value) || value.length === 0) return undefined;
+  const line = integer(value[0]);
+  return line === undefined ? undefined : line + 1;
+}
+
+function symbolKind(value: unknown): string {
+  if (typeof value === 'string' && value.trim()) return value.trim().slice(0, 80);
+  if (typeof value === 'number' && Number.isInteger(value)) return `scip-kind-${value}`;
+  return 'symbol';
+}
+
+function symbolName(symbolId: string, value: unknown): string {
+  const displayName = text(value, 180);
+  if (displayName) return displayName;
+  const pieces = symbolId.split(/[/#.:]/).filter(Boolean);
+  return (pieces[pieces.length - 1] || symbolId).slice(0, 180);
+}
+
+function relationKind(relationship: Record<string, unknown>): string {
+  if (relationship.isImplementation === true || relationship.is_implementation === true) return 'implements';
+  if (relationship.isDefinition === true || relationship.is_definition === true) return 'defines';
+  if (relationship.isReference === true || relationship.is_reference === true) return 'references';
+  return 'references';
+}
+
+interface ScipNodeInfo {
+  symbolId: string;
+  node: ExternalCodeGraphSymbol;
+  defined: boolean;
+  line?: number;
+  relationships: Array<{ target: string; kind: string }>;
+}
+
+/** Normalize a bounded `scip print --json` payload into Memorix's outline. */
+export function normalizeScipOutline(value: unknown, options: ScipOutlineOptions): CodeGraphOutline | undefined {
+  if (!isRecord(value) || !Array.isArray(value.documents)) return undefined;
+  const maxNodes = Math.max(2, Math.min(64, Math.floor(options.maxNodes ?? DEFAULT_MAX_NODES)));
+  const maxEdges = Math.max(1, Math.min(96, Math.floor(options.maxEdges ?? DEFAULT_MAX_EDGES)));
+  const maxFiles = Math.max(1, Math.min(32, Math.floor(options.maxFiles ?? DEFAULT_MAX_FILES)));
+  const nodes = new Map<string, ScipNodeInfo>();
+  const relatedFiles = new Set<string>();
+  const definitions = new Set<string>();
+
+  for (const document of value.documents.slice(0, maxFiles * 4)) {
+    if (!isRecord(document)) continue;
+    const filePath = safeRelativePath(options.projectRoot, document.relativePath ?? document.relative_path, options.exclude);
+    if (!filePath || relatedFiles.size >= maxFiles && !relatedFiles.has(filePath)) continue;
+    relatedFiles.add(filePath);
+    const occurrences = Array.isArray(document.occurrences) ? document.occurrences : [];
+    const definitionLines = new Map<string, number>();
+    for (const occurrence of occurrences) {
+      if (!isRecord(occurrence)) continue;
+      const id = text(occurrence.symbol, 240);
+      const isDefinition = occurrence.isDefinition === true || occurrence.is_definition === true;
+      const rawRoles = occurrence.symbolRoles ?? occurrence.symbol_roles;
+      if (!id || (rawRoles === undefined && !isDefinition)) continue;
+      const roles = integer(rawRoles) ?? 0;
+      // SCIP SymbolRole.Definition is bit 1. Accept the explicit boolean used
+      // by a few JSON emitters as well, without trusting arbitrary roles.
+      if ((roles & 1) !== 0 || isDefinition) {
+        definitions.add(id);
+        const line = lineFromRange(occurrence.range);
+        if (line !== undefined) definitionLines.set(id, line);
+      }
+    }
+
+    const symbolInfos = Array.isArray(document.symbols) ? document.symbols : [];
+    for (const rawSymbol of symbolInfos) {
+      if (!isRecord(rawSymbol)) continue;
+      const id = text(rawSymbol.symbol, 240);
+      if (!id || nodes.has(id)) continue;
+      const relationships: Array<{ target: string; kind: string }> = [];
+      if (Array.isArray(rawSymbol.relationships)) {
+        for (const rawRelationship of rawSymbol.relationships.slice(0, 32)) {
+          if (!isRecord(rawRelationship)) continue;
+          const target = text(rawRelationship.symbol, 240);
+          if (target) relationships.push({ target, kind: relationKind(rawRelationship) });
+        }
+      }
+      nodes.set(id, {
+        symbolId: id,
+        node: {
+          id,
+          name: symbolName(id, rawSymbol.displayName ?? rawSymbol.display_name),
+          qualifiedName: text(rawSymbol.displayName ?? rawSymbol.display_name, 220),
+          kind: symbolKind(rawSymbol.kind),
+          path: filePath,
+          language: text(document.language, 80),
+          ...(definitionLines.has(id) ? { startLine: definitionLines.get(id) } : {}),
+        },
+        defined: definitions.has(id),
+        ...(definitionLines.has(id) ? { line: definitionLines.get(id) } : {}),
+        relationships,
+      });
+    }
+  }
+
+  if (nodes.size === 0) return undefined;
+
+  const selectedNodes = [...nodes.values()]
+    .sort((left, right) => Number(right.defined) - Number(left.defined) || left.node.path.localeCompare(right.node.path) || left.node.name.localeCompare(right.node.name))
+    .slice(0, maxNodes);
+  const selectedById = new Map(selectedNodes.map(item => [item.symbolId, item]));
+  const relations: ExternalCodeGraphRelation[] = [];
+  for (const source of selectedNodes) {
+    for (const relationship of source.relationships) {
+      const target = selectedById.get(relationship.target);
+      if (!target || relations.length >= maxEdges) continue;
+      relations.push({
+        from: source.node,
+        to: target.node,
+        kind: relationship.kind,
+        ...(source.line ? { line: source.line } : {}),
+      });
+    }
+  }
+
+  const entryPoints = selectedNodes
+    .filter(item => item.defined)
+    .slice(0, 5)
+    .map(item => item.node);
+  return {
+    provider: 'external',
+    entryPoints: entryPoints.length > 0 ? entryPoints : selectedNodes.slice(0, 5).map(item => item.node),
+    relations,
+    relatedFiles: [...new Set(selectedNodes.map(item => item.node.path))].slice(0, maxFiles),
+    stats: {
+      nodes: nodes.size,
+      edges: relations.length,
+      files: relatedFiles.size,
+    },
+  };
+}

package/src/codegraph/semantic-context.ts

@@ -0,0 +1,139 @@
+import type { CodeGraphOutline, CodeGraphProviderQuality, CodeGraphStatus, CodeSymbol } from './types.js';
+import type { CodeGraphStore } from './store.js';
+
+interface SemanticContextInput {
+  store: CodeGraphStore;
+  projectId: string;
+  task: string;
+  preferredPaths?: string[];
+  maxNodes?: number;
+  maxEdges?: number;
+}
+
+function tokens(text: string): string[] {
+  return [...new Set((text.toLowerCase().match(/[a-z0-9_$./-]+|[\u4e00-\u9fff]+/g) ?? [])
+    .filter(token => token.length > 1))];
+}
+
+function scoreSymbol(symbol: CodeSymbol, taskTokens: string[], preferred: Set<string>): number {
+  const name = `${symbol.name} ${symbol.qualifiedName} ${symbol.path}`.toLowerCase();
+  let score = preferred.has(symbol.path) ? 100 : 0;
+  for (const token of taskTokens) {
+    if (symbol.name.toLowerCase() === token) score += 20;
+    else if (name.includes(token)) score += 6;
+  }
+  if (score > 0 && (symbol.kind === 'function' || symbol.kind === 'method')) score += 1;
+  return score;
+}
+
+/** Build a small internal semantic outline from the persisted compiler graph. */
+export function buildSemanticContext(input: SemanticContextInput): CodeGraphOutline | undefined {
+  const maxNodes = Math.max(2, Math.min(16, Math.floor(input.maxNodes ?? 8)));
+  const maxEdges = Math.max(1, Math.min(24, Math.floor(input.maxEdges ?? 12)));
+  const taskTokens = tokens(input.task);
+  const preferred = new Set((input.preferredPaths ?? []).map(path => path.replace(/\\/g, '/')));
+  const symbols = input.store.listSymbols(input.projectId)
+    .filter(symbol => symbol.source === 'typescript-compiler' && !symbol.stale)
+    .map((symbol, index) => ({ symbol, score: scoreSymbol(symbol, taskTokens, preferred), index }))
+    .filter(item => item.score > 0)
+    .sort((a, b) => b.score - a.score || a.symbol.path.localeCompare(b.symbol.path) || a.symbol.startLine! - b.symbol.startLine! || a.index - b.index)
+    .slice(0, maxNodes)
+    .map(item => item.symbol);
+  if (symbols.length === 0) return undefined;
+
+  const byId = new Map(symbols.map(symbol => [symbol.id, symbol]));
+  const edges = input.store.listEdges(input.projectId)
+    .filter(edge => edge.source === 'typescript-compiler')
+    .filter(edge => (edge.fromSymbolId && byId.has(edge.fromSymbolId)) || (edge.toSymbolId && byId.has(edge.toSymbolId)))
+    .slice(0, maxEdges);
+  const endpointIds = new Set<string>();
+  for (const edge of edges) {
+    if (edge.fromSymbolId) endpointIds.add(edge.fromSymbolId);
+    if (edge.toSymbolId) endpointIds.add(edge.toSymbolId);
+  }
+  const endpointSymbols = input.store.listSymbols(input.projectId)
+    .filter(symbol => symbol.source === 'typescript-compiler' && endpointIds.has(symbol.id));
+  const allSymbols = [...symbols, ...endpointSymbols]
+    .filter((symbol, index, items) => items.findIndex(item => item.id === symbol.id) === index)
+    .slice(0, maxNodes + maxEdges);
+  const allById = new Map(allSymbols.map(symbol => [symbol.id, symbol]));
+  const relations = edges.flatMap(edge => {
+    const from = edge.fromSymbolId ? allById.get(edge.fromSymbolId) : undefined;
+    const to = edge.toSymbolId ? allById.get(edge.toSymbolId) : undefined;
+    if (!from || !to) return [];
+    return [{
+      from: {
+        id: from.id,
+        name: from.name,
+        qualifiedName: from.qualifiedName,
+        kind: from.kind,
+        path: from.path,
+        ...(from.startLine ? { startLine: from.startLine } : {}),
+        ...(from.endLine ? { endLine: from.endLine } : {}),
+        language: 'typescript',
+      },
+      to: {
+        id: to.id,
+        name: to.name,
+        qualifiedName: to.qualifiedName,
+        kind: to.kind,
+        path: to.path,
+        ...(to.startLine ? { startLine: to.startLine } : {}),
+        ...(to.endLine ? { endLine: to.endLine } : {}),
+        language: 'typescript',
+      },
+      kind: edge.type,
+      ...(edge.evidence?.match(/line (\d+)/)?.[1] ? { line: Number(edge.evidence.match(/line (\d+)/)![1]) } : {}),
+    }];
+  });
+  const entryPoints = symbols.slice(0, Math.min(5, symbols.length)).map(symbol => ({
+    id: symbol.id,
+    name: symbol.name,
+    qualifiedName: symbol.qualifiedName,
+    kind: symbol.kind,
+    path: symbol.path,
+    ...(symbol.startLine ? { startLine: symbol.startLine } : {}),
+    ...(symbol.endLine ? { endLine: symbol.endLine } : {}),
+    language: 'typescript',
+  }));
+  const files = input.store.listFiles(input.projectId);
+  const fileById = new Map(files.map(file => [file.id, file.path]));
+  const relatedFiles = [...new Set([
+    ...allSymbols.map(symbol => symbol.path),
+    ...edges.flatMap(edge => [
+      edge.fromFileId ? fileById.get(edge.fromFileId) : undefined,
+      edge.toFileId ? fileById.get(edge.toFileId) : undefined,
+    ]),
+  ].filter((path): path is string => Boolean(path)))].slice(0, 8);
+  return {
+    provider: 'semantic',
+    entryPoints,
+    relations,
+    relatedFiles,
+    stats: {
+      nodes: allSymbols.length,
+      edges: relations.length,
+      files: relatedFiles.length,
+    },
+  };
+}
+
+export function qualityWithPersistedSemantic(
+  quality: CodeGraphProviderQuality,
+  status: Pick<CodeGraphStatus, 'semanticSymbols' | 'semanticEdges' | 'parserErrors'>,
+): CodeGraphProviderQuality {
+  const hasSemantic = status.semanticSymbols > 0 || status.semanticEdges > 0;
+  const semantic = {
+    state: status.parserErrors > 0 ? 'partial' as const : !hasSemantic ? 'not-indexed' as const : 'ready' as const,
+    symbols: status.semanticSymbols,
+    edges: status.semanticEdges,
+    parserErrors: status.parserErrors,
+  };
+  return {
+    ...quality,
+    semantic,
+    ...(hasSemantic && quality.selected !== 'external'
+      ? { selected: 'semantic' as const, selectedQuality: 'semantic' as const }
+      : {}),
+  };
+}