@monoes/monograph 1.5.6 → 1.5.8

package/src/mcp-tools/group-list.ts

@@ -1,88 +0,0 @@
-/**
- * MCP Tool backing for monograph_group_list
- *
- * Returns metadata for each repo in a group: index timestamp and node count.
- */
-
-import { join } from 'path';
-import { existsSync } from 'fs';
-import Database from 'better-sqlite3';
-import { parseGroupConfig } from '../groups/group-config.js';
-
-export interface GroupRepoInfo {
-  name: string;
-  path: string;
-  indexedAt: string | null;
-  nodeCount: number;
-  error?: string;
-}
-
-export interface GroupListResult {
-  groups: GroupInfo[];
-}
-
-export interface GroupInfo {
-  name: string;
-  repos: GroupRepoInfo[];
-}
-
-function getRepoDbPath(repoPath: string): string {
-  return join(repoPath, '.monomind', 'monograph.db');
-}
-
-function readRepoStats(
-  repoPath: string,
-): { indexedAt: string | null; nodeCount: number; error?: string } {
-  const dbPath = getRepoDbPath(repoPath);
-  if (!existsSync(dbPath)) {
-    return { indexedAt: null, nodeCount: 0, error: 'index not found' };
-  }
-
-  let db: Database.Database | null = null;
-  try {
-    db = new Database(dbPath, { readonly: true });
-
-    const metaRow = db
-      .prepare(`SELECT value FROM index_meta WHERE key = 'indexed_at'`)
-      .get() as { value: string } | undefined;
-
-    const countRow = db.prepare(`SELECT COUNT(*) as cnt FROM nodes`).get() as { cnt: number };
-
-    return { indexedAt: metaRow?.value ?? null, nodeCount: countRow.cnt };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { indexedAt: null, nodeCount: 0, error: message };
-  } finally {
-    db?.close();
-  }
-}
-
-/**
- * Get list information for all repos in a group.
- *
- * @param configPath - Path to group.yaml (defaults to ./group.yaml)
- */
-export async function getGroupList(configPath?: string): Promise<GroupListResult> {
-  const resolvedPath = configPath ?? join(process.cwd(), 'group.yaml');
-  const config = parseGroupConfig(resolvedPath);
-
-  const repos: GroupRepoInfo[] = config.repos.map((repo) => {
-    const { indexedAt, nodeCount, error } = readRepoStats(repo.path);
-    return {
-      name: repo.name,
-      path: repo.path,
-      indexedAt,
-      nodeCount,
-      ...(error ? { error } : {}),
-    };
-  });
-
-  return {
-    groups: [
-      {
-        name: config.name,
-        repos,
-      },
-    ],
-  };
-}

package/src/mcp-tools/group-query.ts

@@ -1,26 +0,0 @@
-/**
- * MCP Tool backing for monograph_group_query
- *
- * Parses a group.yaml then runs a merged BM25 cross-repo search.
- */
-
-import { join } from 'path';
-import { parseGroupConfig } from '../groups/group-config.js';
-import { groupQuery, type GroupResult } from '../groups/group-search.js';
-
-/**
- * Run a group-wide query.
- *
- * @param groupConfigPath - Path to group.yaml (defaults to ./group.yaml)
- * @param query           - Search query string
- * @param limit           - Max results (default 20)
- */
-export async function runGroupQuery(
-  groupConfigPath: string | undefined,
-  query: string,
-  limit?: number,
-): Promise<GroupResult[]> {
-  const configPath = groupConfigPath ?? join(process.cwd(), 'group.yaml');
-  const config = parseGroupConfig(configPath);
-  return groupQuery(config, query, { limit: limit ?? 20 });
-}

package/src/mcp-tools/group-sync.ts

@@ -1,32 +0,0 @@
-/**
- * MCP Tool backing for monograph_group_sync
- *
- * Rebuilds the Contract Registry for a group: scans each repo for Route nodes,
- * finds cross-repo HTTP contracts, and persists the registry to disk.
- */
-
-import { join } from 'path';
-import { existsSync } from 'fs';
-import { syncGroup, type GroupSyncResult } from '../groups/group-sync.js';
-
-export type { GroupSyncResult };
-
-/**
- * Run a group contract registry sync.
- *
- * @param configPath - Path to group.yaml (defaults to ./group.yaml in cwd)
- * @returns Summary of the sync operation
- * @throws {Error} If the config file is not found
- */
-export async function runGroupSync(configPath?: string): Promise<GroupSyncResult> {
-  const resolvedPath = configPath ?? join(process.cwd(), 'group.yaml');
-
-  if (!existsSync(resolvedPath)) {
-    throw new Error(
-      `Group config not found: ${resolvedPath}. ` +
-        `Create a group.yaml file or pass an explicit configPath.`,
-    );
-  }
-
-  return syncGroup(resolvedPath);
-}

package/src/mcp-tools/impact.ts

@@ -1,202 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-// ── Row → MonographNode mapper ─────────────────────────────────────────────────
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row.id as string,
-    label: row.label as MonographNode['label'],
-    name: row.name as string,
-    normLabel: row.norm_label as string,
-    filePath: row.file_path as string | undefined,
-    startLine: row.start_line as number | undefined,
-    endLine: row.end_line as number | undefined,
-    communityId: row.community_id as number | undefined,
-    isExported: (row.is_exported as number) === 1,
-    language: row.language as string | undefined,
-    properties: row.properties ? JSON.parse(row.properties as string) : undefined,
-  };
-}
-
-// ── Risk level ─────────────────────────────────────────────────────────────────
-
-export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-
-export function computeRiskLevel(riskScore: number): RiskLevel {
-  if (riskScore > 0.75) return 'CRITICAL';
-  if (riskScore > 0.5) return 'HIGH';
-  if (riskScore > 0.25) return 'MEDIUM';
-  return 'LOW';
-}
-
-// ── Options ────────────────────────────────────────────────────────────────────
-
-export interface ImpactOptions {
-  minConfidenceScore?: number;
-  relationTypes?: string[];
-  maxDepth?: number;
-}
-
-// ── Output type ────────────────────────────────────────────────────────────────
-
-export interface MonographImpactResult {
-  node: MonographNode | null;
-  directCallers: MonographNode[];
-  transitiveCallers: Array<{ depth: number; nodes: MonographNode[] }>;
-  affectedFiles: string[];
-  riskScore: number;
-  riskLevel: RiskLevel;
-}
-
-// ── Reverse BFS on CALLS edges ────────────────────────────────────────────────
-
-function reverseBfs(
-  startNodeId: string,
-  db: Database.Database,
-  maxDepth: number,
-  options: ImpactOptions = {},
-): Map<string, number> {
-  const visited = new Map<string, number>([[startNodeId, 0]]);
-  const queue: Array<{ id: string; depth: number }> = [{ id: startNodeId, depth: 0 }];
-
-  // Default to a broad set of relation types, not just CALLS — a class extended
-  // in 20 files, or a function only ever referenced via import/re-export (never
-  // directly called), should still show up in the blast radius. A narrow default
-  // reports "0 symbols affected, risk LOW" for changes that are anything but low
-  // risk. Callers that need the old narrow/fast behavior can still pass
-  // relationTypes: ['CALLS'] explicitly.
-  const relations = options.relationTypes ?? ['CALLS', 'IMPORTS', 'REFERENCES', 'EXTENDS', 'RE_EXPORTS'];
-  const placeholders = relations.map(() => '?').join(',');
-  const baseQuery = `SELECT source_id FROM edges WHERE target_id = ? AND relation IN (${placeholders})`;
-  const query = options.minConfidenceScore !== undefined
-    ? `${baseQuery} AND confidence_score >= ?`
-    : baseQuery;
-
-  const stmt = db.prepare(query);
-
-  while (queue.length > 0) {
-    const { id, depth } = queue.shift()!;
-    if (depth >= maxDepth) continue;
-
-    const params: unknown[] = [id, ...relations];
-    if (options.minConfidenceScore !== undefined) {
-      params.push(options.minConfidenceScore);
-    }
-    const callers = stmt.all(...params) as Array<{ source_id: string }>;
-    for (const { source_id } of callers) {
-      if (!visited.has(source_id)) {
-        visited.set(source_id, depth + 1);
-        queue.push({ id: source_id, depth: depth + 1 });
-      }
-    }
-  }
-
-  return visited;
-}
-
-// ── Implementation ─────────────────────────────────────────────────────────────
-
-export function getMonographImpact(
-  db: Database.Database,
-  input: { name: string; filePath?: string; depth?: number },
-): MonographImpactResult {
-  const maxDepth = Math.min(input.depth ?? 3, 6);
-
-  // Find the node
-  let nodeRow: Record<string, unknown> | undefined;
-  if (input.filePath) {
-    nodeRow = db
-      .prepare('SELECT * FROM nodes WHERE name = ? AND file_path = ? LIMIT 1')
-      .get(input.name, input.filePath) as Record<string, unknown> | undefined;
-  } else {
-    nodeRow = db
-      .prepare('SELECT * FROM nodes WHERE name = ? LIMIT 1')
-      .get(input.name) as Record<string, unknown> | undefined;
-  }
-
-  if (!nodeRow) {
-    return { node: null, directCallers: [], transitiveCallers: [], affectedFiles: [], riskScore: 0, riskLevel: 'LOW' };
-  }
-
-  const node = rowToNode(nodeRow);
-  const nodeId = node.id;
-
-  // Reverse BFS to find all callers (depth 0 = start node)
-  const visited = reverseBfs(nodeId, db, maxDepth, {});
-  return { node, ...extractCallerResult(db, nodeId, visited) };
-}
-
-// ── Shared helper: fetch nodes by IDs in a single query ───────────────────────
-
-function getNodesByIds(db: Database.Database, ids: string[]): MonographNode[] {
-  if (ids.length === 0) return [];
-  const placeholders = ids.map(() => '?').join(',');
-  const rows = db
-    .prepare(`SELECT * FROM nodes WHERE id IN (${placeholders})`)
-    .all(...ids) as Record<string, unknown>[];
-  return rows.map(rowToNode);
-}
-
-// ── Shared helper: turn a visited map into structured caller lists ─────────────
-
-function extractCallerResult(
-  db: Database.Database,
-  startNodeId: string,
-  visited: Map<string, number>,
-): Omit<MonographImpactResult, 'node'> {
-  const directCallerIds: string[] = [];
-  const byDepth = new Map<number, string[]>();
-
-  for (const [id, depth] of visited.entries()) {
-    if (id === startNodeId) continue;
-    if (depth === 1) {
-      directCallerIds.push(id);
-    } else {
-      const existing = byDepth.get(depth) ?? [];
-      existing.push(id);
-      byDepth.set(depth, existing);
-    }
-  }
-
-  const directCallers = getNodesByIds(db, directCallerIds);
-
-  const transitiveCallers: Array<{ depth: number; nodes: MonographNode[] }> = [];
-  const sortedDepths = Array.from(byDepth.keys()).sort((a, b) => a - b);
-  for (const depth of sortedDepths) {
-    transitiveCallers.push({ depth, nodes: getNodesByIds(db, byDepth.get(depth)!) });
-  }
-
-  const allAffectedNodes = [...directCallers, ...transitiveCallers.flatMap(t => t.nodes)];
-  const affectedFiles = [...new Set(
-    allAffectedNodes.map(n => n.filePath).filter((p): p is string => p != null),
-  )];
-
-  const totalCallerCount = visited.size - 1; // exclude start node
-  const rawScore = Math.min(Math.log2(totalCallerCount + 1), 10);
-  const riskScore = rawScore / 10;
-
-  return { directCallers, transitiveCallers, affectedFiles, riskScore, riskLevel: computeRiskLevel(riskScore) };
-}
-
-// ── id-based impact with filtering options ────────────────────────────────────
-
-export async function monographImpact(
-  db: Database.Database,
-  nodeId: string,
-  options: ImpactOptions = {},
-): Promise<MonographImpactResult> {
-  const maxDepth = Math.min(options.maxDepth ?? 3, 6);
-
-  const nodeRow = db
-    .prepare('SELECT * FROM nodes WHERE id = ? LIMIT 1')
-    .get(nodeId) as Record<string, unknown> | undefined;
-
-  if (!nodeRow) {
-    return { node: null, directCallers: [], transitiveCallers: [], affectedFiles: [], riskScore: 0, riskLevel: 'LOW' };
-  }
-
-  const node = rowToNode(nodeRow);
-  const visited = reverseBfs(nodeId, db, maxDepth, options);
-  return { node, ...extractCallerResult(db, nodeId, visited) };
-}

package/src/mcp-tools/index.ts

@@ -1,21 +0,0 @@
-export * from './context.js';
-export * from './impact.js';
-export * from './detect-changes.js';
-export * from './rename.js';
-export * from './staleness.js';
-export * from './route-map.js';
-export * from './api-impact.js';
-export * from './cypher.js';
-export * from './group-query.js';
-export * from './group-list.js';
-export * from './wiki.js';
-export * from './wiki-build.js';
-export * from './serve.js';
-export * from './tool-map.js';
-export * from './shape-check.js';
-export * from './neighbors.js';
-export * from './graph-query.js';
-export * from './explain.js';
-export * from './group-sync.js';
-export * from './list-repos.js';
-export * from './query.js';

package/src/mcp-tools/list-repos.ts

@@ -1,38 +0,0 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { listRepos } from '../registry/repo-registry.js';
-
-export interface ListReposResult {
-  repos: Array<{
-    name: string;
-    path: string;
-    dbPath: string;
-    exists: boolean;
-    indexedAt?: string;
-  }>;
-}
-
-export const listReposTool = {
-  name: 'monograph_list_repos',
-  description: 'List all repositories indexed by monograph with their metadata.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {},
-    required: [] as string[],
-  },
-  async handler(_args: Record<string, unknown>): Promise<ListReposResult> {
-    const repos = listRepos();
-    return {
-      repos: repos.map((r) => {
-        const dbPath = join(r.path, '.monomind', 'monograph.db');
-        return {
-          name: r.name,
-          path: r.path,
-          dbPath,
-          exists: existsSync(dbPath),
-          indexedAt: r.lastIndexed,
-        };
-      }),
-    };
-  },
-};

package/src/mcp-tools/neighbors.ts

@@ -1,80 +0,0 @@
-import type Database from 'better-sqlite3';
-import type { MonographNode } from '../types.js';
-
-function rowToNode(row: Record<string, unknown>): MonographNode {
-  return {
-    id: row['id'] as string,
-    label: row['label'] as MonographNode['label'],
-    name: row['name'] as string,
-    normLabel: (row['norm_label'] as string) ?? '',
-    filePath: row['file_path'] as string | undefined,
-    startLine: row['start_line'] as number | undefined,
-    endLine: row['end_line'] as number | undefined,
-    communityId: row['community_id'] as number | undefined,
-    isExported: (row['is_exported'] as number) === 1,
-    language: row['language'] as string | undefined,
-    properties: row['properties'] ? JSON.parse(row['properties'] as string) : undefined,
-  };
-}
-
-export interface NeighborEntry {
-  node: MonographNode;
-  relation: string;
-  confidence: string;
-  confidenceScore: number;
-  direction: 'outbound' | 'inbound';
-}
-
-export interface MonographNeighborsResult {
-  node: MonographNode | null;
-  neighbors: NeighborEntry[];
-}
-
-// ── Shared edge query helper ──────────────────────────────────────────────────
-
-function queryEdges(
-  db: Database.Database,
-  nodeId: string,
-  direction: 'outbound' | 'inbound',
-  relationFilter?: string,
-): NeighborEntry[] {
-  // outbound: source_id = nodeId → join target_id
-  // inbound:  target_id = nodeId → join source_id
-  const [idCol, joinCol] = direction === 'outbound'
-    ? ['source_id', 'target_id']
-    : ['target_id', 'source_id'];
-
-  const sql = relationFilter
-    ? `SELECT n.*, e.relation, e.confidence, e.confidence_score FROM nodes n JOIN edges e ON n.id = e.${joinCol} WHERE e.${idCol} = ? AND e.relation = ? LIMIT 50`
-    : `SELECT n.*, e.relation, e.confidence, e.confidence_score FROM nodes n JOIN edges e ON n.id = e.${joinCol} WHERE e.${idCol} = ? LIMIT 50`;
-
-  const params = relationFilter ? [nodeId, relationFilter] : [nodeId];
-  const rows = db.prepare(sql).all(...params) as Record<string, unknown>[];
-
-  return rows.map(row => ({
-    node: rowToNode(row),
-    relation: row['relation'] as string,
-    confidence: row['confidence'] as string,
-    confidenceScore: (row['confidence_score'] as number) ?? 1,
-    direction,
-  }));
-}
-
-export function getMonographNeighbors(
-  db: Database.Database,
-  input: { name: string; relationFilter?: string; includeInbound?: boolean },
-): MonographNeighborsResult {
-  const nodeRow = db
-    .prepare('SELECT * FROM nodes WHERE name = ? LIMIT 1')
-    .get(input.name) as Record<string, unknown> | undefined;
-
-  if (!nodeRow) return { node: null, neighbors: [] };
-
-  const node = rowToNode(nodeRow);
-  const neighbors: NeighborEntry[] = [
-    ...queryEdges(db, node.id, 'outbound', input.relationFilter),
-    ...(input.includeInbound ? queryEdges(db, node.id, 'inbound', input.relationFilter) : []),
-  ];
-
-  return { node, neighbors };
-}

package/src/mcp-tools/query.ts

@@ -1,86 +0,0 @@
-import { join } from 'path';
-import { openDb, closeDb } from '../storage/db.js';
-import { hybridQuery } from '../search/hybrid-query.js';
-import type { MonographDb } from '../storage/db.js';
-
-export interface QueryResult {
-  id: string;
-  label: string;
-  name: string;
-  filePath?: string;
-  /** Line number where the symbol is defined — enables direct file:line navigation. */
-  startLine?: number | null;
-  score: number;
-  isProcess: boolean;
-}
-
-export interface MonographQueryOutput {
-  query: string;
-  results: QueryResult[];
-  processCount: number;
-  symbolCount: number;
-}
-
-export const monographQueryTool = {
-  name: 'monograph_query',
-  description:
-    'Process-aware hybrid search across the monograph knowledge graph. Returns symbols and process nodes ranked by relevance.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      query: { type: 'string', description: 'Search query' },
-      repoPath: { type: 'string', description: 'Absolute path to the repository root' },
-      topK: { type: 'number', description: 'Max results to return (default: 20)' },
-      includeProcesses: {
-        type: 'boolean',
-        description: 'Include Process nodes in results (default: true)',
-      },
-    },
-    required: ['query'],
-  },
-  async handler(args: {
-    query: string;
-    repoPath?: string;
-    topK?: number;
-    includeProcesses?: boolean;
-    db?: MonographDb;
-  }): Promise<MonographQueryOutput> {
-    const { query, repoPath, topK = 20, includeProcesses = true } = args;
-
-    let db: MonographDb | null = null;
-    let shouldClose = false;
-
-    if (args.db) {
-      db = args.db;
-    } else if (repoPath) {
-      db = openDb(join(repoPath, '.monomind', 'monograph.db'));
-      shouldClose = true;
-    } else {
-      return { query, results: [], processCount: 0, symbolCount: 0 };
-    }
-
-    try {
-      const hits = await hybridQuery(db, query, { limit: topK * 3 });
-      const results: QueryResult[] = hits
-        .filter(h => includeProcesses || h.label !== 'Process')
-        .map(h => ({
-          id: h.id,
-          label: h.label ?? 'Symbol',
-          name: h.name ?? h.id,
-          filePath: h.filePath ?? undefined,
-          startLine: h.startLine ?? null,
-          score: h.score,
-          isProcess: h.label === 'Process',
-        }));
-
-      return {
-        query,
-        results,
-        processCount: results.filter(r => r.isProcess).length,
-        symbolCount: results.filter(r => !r.isProcess).length,
-      };
-    } finally {
-      if (shouldClose && db) closeDb(db);
-    }
-  },
-};