@optave/codegraph 3.3.1 → 3.4.1

package/src/shared/{file-utils.js → file-utils.ts}

@@ -7,13 +7,23 @@ import { debug } from '../infrastructure/logger.js';
  * Resolve a file path relative to repoRoot, rejecting traversal outside the repo.
  * Returns null if the resolved path escapes repoRoot.
  */
-export function safePath(repoRoot, file) {
+export function safePath(repoRoot: string, file: string): string | null {
   const resolved = path.resolve(repoRoot, file);
   if (!resolved.startsWith(repoRoot + path.sep) && resolved !== repoRoot) return null;
   return resolved;
 }
 
-export function readSourceRange(repoRoot, file, startLine, endLine, opts = {}) {
+interface ReadSourceRangeOpts {
+  excerptLines?: number;
+}
+
+export function readSourceRange(
+  repoRoot: string,
+  file: string,
+  startLine: number | undefined,
+  endLine: number | undefined,
+  opts: ReadSourceRangeOpts = {},
+): string | null {
   try {
     const absPath = safePath(repoRoot, file);
     if (!absPath) return null;
@@ -21,15 +31,25 @@ export function readSourceRange(repoRoot, file, startLine, endLine, opts = {}) {
     const lines = content.split('\n');
     const excerptLines = opts.excerptLines ?? 50;
     const start = Math.max(0, (startLine || 1) - 1);
-    const end = Math.min(lines.length, endLine || startLine + excerptLines);
+    const end = Math.min(lines.length, endLine || (startLine || 1) + excerptLines);
     return lines.slice(start, end).join('\n');
-  } catch (e) {
-    debug(`readSourceRange failed for ${file}: ${e.message}`);
+  } catch (e: unknown) {
+    debug(`readSourceRange failed for ${file}: ${(e as Error).message}`);
     return null;
   }
 }
 
-export function extractSummary(fileLines, line, opts = {}) {
+interface ExtractSummaryOpts {
+  jsdocEndScanLines?: number;
+  jsdocOpenScanLines?: number;
+  summaryMaxChars?: number;
+}
+
+export function extractSummary(
+  fileLines: string[] | null,
+  line: number | undefined,
+  opts: ExtractSummaryOpts = {},
+): string | null {
   if (!fileLines || !line || line <= 1) return null;
   const idx = line - 2; // line above the definition (0-indexed)
   const jsdocEndScanLines = opts.jsdocEndScanLines ?? 10;
@@ -38,7 +58,7 @@ export function extractSummary(fileLines, line, opts = {}) {
   // Scan up for JSDoc or comment
   let jsdocEnd = -1;
   for (let i = idx; i >= Math.max(0, idx - jsdocEndScanLines); i--) {
-    const trimmed = fileLines[i].trim();
+    const trimmed = fileLines[i]!.trim();
     if (trimmed.endsWith('*/')) {
       jsdocEnd = i;
       break;
@@ -56,11 +76,10 @@ export function extractSummary(fileLines, line, opts = {}) {
   if (jsdocEnd >= 0) {
     // Find opening /**
     for (let i = jsdocEnd; i >= Math.max(0, jsdocEnd - jsdocOpenScanLines); i--) {
-      if (fileLines[i].trim().startsWith('/**')) {
+      if (fileLines[i]!.trim().startsWith('/**')) {
         // Extract first non-tag, non-empty line
         for (let j = i + 1; j <= jsdocEnd; j++) {
-          const docLine = fileLines[j]
-            .trim()
+          const docLine = fileLines[j]!.trim()
             .replace(/^\*\s?/, '')
             .trim();
           if (docLine && !docLine.startsWith('@') && docLine !== '/' && docLine !== '*/') {
@@ -76,7 +95,20 @@ export function extractSummary(fileLines, line, opts = {}) {
   return null;
 }
 
-export function extractSignature(fileLines, line, opts = {}) {
+interface ExtractSignatureOpts {
+  signatureGatherLines?: number;
+}
+
+export interface Signature {
+  params: string | null;
+  returnType: string | null;
+}
+
+export function extractSignature(
+  fileLines: string[] | null,
+  line: number | undefined,
+  opts: ExtractSignatureOpts = {},
+): Signature | null {
   if (!fileLines || !line) return null;
   const idx = line - 1;
   const signatureGatherLines = opts.signatureGatherLines ?? 5;
@@ -91,7 +123,7 @@ export function extractSignature(fileLines, line, opts = {}) {
   );
   if (m) {
     return {
-      params: m[1].trim() || null,
+      params: m[1]!.trim() || null,
       returnType: m[2] ? m[2].trim().replace(/\s*\{$/, '') : null,
     };
   }
@@ -99,7 +131,7 @@ export function extractSignature(fileLines, line, opts = {}) {
   m = chunk.match(/=\s*(?:async\s+)?\(([^)]*)\)\s*(?::\s*([^=>\n{]+))?\s*=>/);
   if (m) {
     return {
-      params: m[1].trim() || null,
+      params: m[1]!.trim() || null,
       returnType: m[2] ? m[2].trim() : null,
     };
   }
@@ -107,7 +139,7 @@ export function extractSignature(fileLines, line, opts = {}) {
   m = chunk.match(/def\s+\w+\s*\(([^)]*)\)\s*(?:->\s*([^:\n]+))?/);
   if (m) {
     return {
-      params: m[1].trim() || null,
+      params: m[1]!.trim() || null,
       returnType: m[2] ? m[2].trim() : null,
     };
   }
@@ -115,7 +147,7 @@ export function extractSignature(fileLines, line, opts = {}) {
   m = chunk.match(/func\s+(?:\([^)]*\)\s+)?\w+\s*\(([^)]*)\)\s*(?:\(([^)]+)\)|(\w[^\n{]*))?/);
   if (m) {
     return {
-      params: m[1].trim() || null,
+      params: m[1]!.trim() || null,
       returnType: (m[2] || m[3] || '').trim() || null,
     };
   }
@@ -123,17 +155,17 @@ export function extractSignature(fileLines, line, opts = {}) {
   m = chunk.match(/fn\s+\w+\s*\(([^)]*)\)\s*(?:->\s*([^\n{]+))?/);
   if (m) {
     return {
-      params: m[1].trim() || null,
+      params: m[1]!.trim() || null,
       returnType: m[2] ? m[2].trim() : null,
     };
   }
   return null;
 }
 
-export function createFileLinesReader(repoRoot) {
-  const cache = new Map();
-  return function getFileLines(file) {
-    if (cache.has(file)) return cache.get(file);
+export function createFileLinesReader(repoRoot: string): (file: string) => string[] | null {
+  const cache = new Map<string, string[] | null>();
+  return function getFileLines(file: string): string[] | null {
+    if (cache.has(file)) return cache.get(file)!;
     try {
       const absPath = safePath(repoRoot, file);
       if (!absPath) {
@@ -143,15 +175,15 @@ export function createFileLinesReader(repoRoot) {
       const lines = fs.readFileSync(absPath, 'utf-8').split('\n');
       cache.set(file, lines);
       return lines;
-    } catch (e) {
-      debug(`getFileLines failed for ${file}: ${e.message}`);
+    } catch (e: unknown) {
+      debug(`getFileLines failed for ${file}: ${(e as Error).message}`);
       cache.set(file, null);
       return null;
     }
   };
 }
 
-export function isFileLikeTarget(target) {
+export function isFileLikeTarget(target: string): boolean {
   if (target.includes('/') || target.includes('\\')) return true;
   const ext = path.extname(target).toLowerCase();
   if (!ext) return false;

package/src/shared/{generators.js → generators.ts}

@@ -1,23 +1,39 @@
 import { iterateFunctionNodes, openReadonlyOrFail } from '../db/index.js';
 import { buildFileConditionSQL } from '../db/query-builder.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
+import type { BetterSqlite3Database, NodeRow } from '../types.js';
 import { ALL_SYMBOL_KINDS } from './kinds.js';
 
+interface ListFunctionResult {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine: number | null;
+  role: string | null;
+}
+
+interface IterListOpts {
+  noTests?: boolean;
+  file?: string;
+  pattern?: string;
+}
+
 /**
  * Generator: stream functions one-by-one using .iterate() for memory efficiency.
- * @param {string} [customDbPath]
- * @param {object} [opts]
- * @param {boolean} [opts.noTests]
- * @param {string} [opts.file]
- * @param {string} [opts.pattern]
- * @yields {{ name: string, kind: string, file: string, line: number, role: string|null }}
  */
-export function* iterListFunctions(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+export function* iterListFunctions(
+  customDbPath?: string,
+  opts: IterListOpts = {},
+): Generator<ListFunctionResult> {
+  const db = openReadonlyOrFail(customDbPath) as BetterSqlite3Database;
   try {
     const noTests = opts.noTests || false;
 
-    for (const row of iterateFunctionNodes(db, { file: opts.file, pattern: opts.pattern })) {
+    for (const row of iterateFunctionNodes(db, {
+      file: opts.file,
+      pattern: opts.pattern,
+    }) as IterableIterator<NodeRow>) {
       if (noTests && isTestFile(row.file)) continue;
       yield {
         name: row.name,
@@ -33,28 +49,37 @@ export function* iterListFunctions(customDbPath, opts = {}) {
   }
 }
 
+interface RoleResult {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine: number | null;
+  role: string | null;
+}
+
+interface IterRolesOpts {
+  noTests?: boolean;
+  role?: string;
+  file?: string;
+}
+
 /**
  * Generator: stream role-classified symbols one-by-one.
- * @param {string} [customDbPath]
- * @param {object} [opts]
- * @param {boolean} [opts.noTests]
- * @param {string} [opts.role]
- * @param {string} [opts.file]
- * @yields {{ name: string, kind: string, file: string, line: number, endLine: number|null, role: string }}
  */
-export function* iterRoles(customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+export function* iterRoles(customDbPath?: string, opts: IterRolesOpts = {}): Generator<RoleResult> {
+  const db = openReadonlyOrFail(customDbPath) as BetterSqlite3Database;
   try {
     const noTests = opts.noTests || false;
     const conditions = ['role IS NOT NULL'];
-    const params = [];
+    const params: unknown[] = [];
 
     if (opts.role) {
       conditions.push('role = ?');
       params.push(opts.role);
     }
     {
-      const fc = buildFileConditionSQL(opts.file, 'file');
+      const fc = buildFileConditionSQL(opts.file ?? '', 'file');
       if (fc.sql) {
         conditions.push(fc.sql.replace(/^ AND /, ''));
         params.push(...fc.params);
@@ -64,7 +89,7 @@ export function* iterRoles(customDbPath, opts = {}) {
     const stmt = db.prepare(
       `SELECT name, kind, file, line, end_line, role FROM nodes WHERE ${conditions.join(' AND ')} ORDER BY role, file, line`,
     );
-    for (const row of stmt.iterate(...params)) {
+    for (const row of stmt.iterate(...params) as IterableIterator<NodeRow>) {
       if (noTests && isTestFile(row.file)) continue;
       yield {
         name: row.name,
@@ -80,16 +105,35 @@ export function* iterRoles(customDbPath, opts = {}) {
   }
 }
 
+interface WhereUse {
+  name: string;
+  file: string;
+  line: number;
+}
+
+interface WhereResult {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  role: string | null;
+  exported: boolean;
+  uses: WhereUse[];
+}
+
+interface IterWhereOpts {
+  noTests?: boolean;
+}
+
 /**
  * Generator: stream symbol lookup results one-by-one.
- * @param {string} target - Symbol name to search for (partial match)
- * @param {string} [customDbPath]
- * @param {object} [opts]
- * @param {boolean} [opts.noTests]
- * @yields {{ name: string, kind: string, file: string, line: number, role: string|null, exported: boolean, uses: object[] }}
  */
-export function* iterWhere(target, customDbPath, opts = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+export function* iterWhere(
+  target: string,
+  customDbPath?: string,
+  opts: IterWhereOpts = {},
+): Generator<WhereResult> {
+  const db = openReadonlyOrFail(customDbPath) as BetterSqlite3Database;
   try {
     const noTests = opts.noTests || false;
     const placeholders = ALL_SYMBOL_KINDS.map(() => '?').join(', ');
@@ -104,13 +148,16 @@ export function* iterWhere(target, customDbPath, opts = {}) {
       `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
        WHERE e.target_id = ? AND e.kind = 'calls'`,
     );
-    for (const node of stmt.iterate(`%${target}%`, ...ALL_SYMBOL_KINDS)) {
+    for (const node of stmt.iterate(
+      `%${target}%`,
+      ...ALL_SYMBOL_KINDS,
+    ) as IterableIterator<NodeRow>) {
       if (noTests && isTestFile(node.file)) continue;
 
-      const crossFileCallers = crossFileCallersStmt.get(node.id, node.file);
+      const crossFileCallers = crossFileCallersStmt.get(node.id, node.file) as { cnt: number };
       const exported = crossFileCallers.cnt > 0;
 
-      let uses = usesStmt.all(node.id);
+      let uses = usesStmt.all(node.id) as WhereUse[];
       if (noTests) uses = uses.filter((u) => !isTestFile(u.file));
 
       yield {
@@ -118,7 +165,7 @@ export function* iterWhere(target, customDbPath, opts = {}) {
         kind: node.kind,
         file: node.file,
         line: node.line,
-        role: node.role || null,
+        role: (node.role as string) || null,
         exported,
         uses: uses.map((u) => ({ name: u.name, file: u.file, line: u.line })),
       };

package/src/shared/{hierarchy.js → hierarchy.ts}

@@ -1,25 +1,31 @@
 import { getClassHierarchy } from '../db/index.js';
+import type { BetterSqlite3Database, NodeRow } from '../types.js';
 
-export function resolveMethodViaHierarchy(db, methodName) {
+export function resolveMethodViaHierarchy(
+  db: BetterSqlite3Database,
+  methodName: string,
+): NodeRow[] {
   const methods = db
     .prepare(`SELECT * FROM nodes WHERE kind = 'method' AND name LIKE ?`)
-    .all(`%.${methodName}`);
+    .all(`%.${methodName}`) as NodeRow[];
 
-  const results = [...methods];
+  const results: NodeRow[] = [...methods];
   for (const m of methods) {
     const className = m.name.split('.')[0];
     const classNode = db
       .prepare(`SELECT * FROM nodes WHERE name = ? AND kind = 'class' AND file = ?`)
-      .get(className, m.file);
+      .get(className, m.file) as NodeRow | undefined;
     if (!classNode) continue;
 
     const ancestors = getClassHierarchy(db, classNode.id);
     for (const ancestorId of ancestors) {
-      const ancestor = db.prepare('SELECT name FROM nodes WHERE id = ?').get(ancestorId);
+      const ancestor = db.prepare('SELECT name FROM nodes WHERE id = ?').get(ancestorId) as
+        | { name: string }
+        | undefined;
       if (!ancestor) continue;
       const parentMethods = db
         .prepare(`SELECT * FROM nodes WHERE name = ? AND kind = 'method'`)
-        .all(`${ancestor.name}.${methodName}`);
+        .all(`${ancestor.name}.${methodName}`) as NodeRow[];
       results.push(...parentMethods);
     }
   }

package/src/shared/{kinds.js → kinds.ts}

@@ -1,6 +1,17 @@
+import type {
+  CoreEdgeKind,
+  CoreSymbolKind,
+  DeadSubRole,
+  EdgeKind,
+  ExtendedSymbolKind,
+  Role,
+  StructuralEdgeKind,
+  SymbolKind,
+} from '../types.js';
+
 // ── Symbol kind constants ───────────────────────────────────────────
 // Original 10 kinds — used as default query scope
-export const CORE_SYMBOL_KINDS = [
+export const CORE_SYMBOL_KINDS: readonly CoreSymbolKind[] = [
   'function',
   'method',
   'class',
@@ -11,26 +22,29 @@ export const CORE_SYMBOL_KINDS = [
   'trait',
   'record',
   'module',
-];
+] as const;
 
 // Sub-declaration kinds (Phase 1)
-export const EXTENDED_SYMBOL_KINDS = [
+export const EXTENDED_SYMBOL_KINDS: readonly ExtendedSymbolKind[] = [
   'parameter',
   'property',
   'constant',
   // Phase 2 (reserved, not yet extracted):
   // 'constructor', 'namespace', 'decorator', 'getter', 'setter',
-];
+] as const;
 
 // Full set for --kind validation and MCP enum
-export const EVERY_SYMBOL_KIND = [...CORE_SYMBOL_KINDS, ...EXTENDED_SYMBOL_KINDS];
+export const EVERY_SYMBOL_KIND: readonly SymbolKind[] = [
+  ...CORE_SYMBOL_KINDS,
+  ...EXTENDED_SYMBOL_KINDS,
+];
 
 // Backward compat: ALL_SYMBOL_KINDS stays as the core 10
-export const ALL_SYMBOL_KINDS = CORE_SYMBOL_KINDS;
+export const ALL_SYMBOL_KINDS: readonly CoreSymbolKind[] = CORE_SYMBOL_KINDS;
 
 // ── Edge kind constants ─────────────────────────────────────────────
 // Core edge kinds — coupling and dependency relationships
-export const CORE_EDGE_KINDS = [
+export const CORE_EDGE_KINDS: readonly CoreEdgeKind[] = [
   'imports',
   'imports-type',
   'dynamic-imports',
@@ -39,19 +53,27 @@ export const CORE_EDGE_KINDS = [
   'extends',
   'implements',
   'contains',
-];
+] as const;
 
 // Structural edge kinds — parent/child and type relationships
-export const STRUCTURAL_EDGE_KINDS = ['parameter_of', 'receiver'];
+export const STRUCTURAL_EDGE_KINDS: readonly StructuralEdgeKind[] = [
+  'parameter_of',
+  'receiver',
+] as const;
 
 // Full set for MCP enum and validation
-export const EVERY_EDGE_KIND = [...CORE_EDGE_KINDS, ...STRUCTURAL_EDGE_KINDS];
+export const EVERY_EDGE_KIND: readonly EdgeKind[] = [...CORE_EDGE_KINDS, ...STRUCTURAL_EDGE_KINDS];
 
 // Dead sub-categories — refine the coarse "dead" bucket
 export const DEAD_ROLE_PREFIX = 'dead';
-export const DEAD_SUB_ROLES = ['dead-leaf', 'dead-entry', 'dead-ffi', 'dead-unresolved'];
+export const DEAD_SUB_ROLES: readonly DeadSubRole[] = [
+  'dead-leaf',
+  'dead-entry',
+  'dead-ffi',
+  'dead-unresolved',
+] as const;
 
-export const VALID_ROLES = [
+export const VALID_ROLES: readonly Role[] = [
   'entry',
   'core',
   'utility',

package/src/shared/{normalize.js → normalize.ts}

@@ -1,9 +1,16 @@
-export function getFileHash(db, file) {
-  const row = db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file);
+/** Minimal DB handle — avoids importing better-sqlite3 types directly. */
+interface DbHandle {
+  prepare(sql: string): { get(...params: unknown[]): unknown };
+}
+
+export function getFileHash(db: DbHandle, file: string): string | null {
+  const row = db.prepare('SELECT hash FROM file_hashes WHERE file = ?').get(file) as
+    | { hash: string }
+    | undefined;
   return row ? row.hash : null;
 }
 
-export function kindIcon(kind) {
+export function kindIcon(kind: string): string {
   switch (kind) {
     case 'function':
       return 'f';
@@ -28,21 +35,41 @@ export function kindIcon(kind) {
   }
 }
 
+export interface NormalizedSymbol {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  endLine: number | null;
+  role: string | null;
+  fileHash: string | null;
+}
+
+interface RawSymbolRow {
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  end_line?: number | null;
+  endLine?: number | null;
+  role?: string | null;
+}
+
 /**
  * Normalize a raw DB/query row into the stable 7-field symbol shape.
- * @param {object} row    - Raw row (from SELECT * or explicit columns)
- * @param {object} [db]   - Open DB handle; when null, fileHash will be null
- * @param {Map}    [hashCache] - Optional per-file cache to avoid repeated getFileHash calls
- * @returns {{ name: string, kind: string, file: string, line: number, endLine: number|null, role: string|null, fileHash: string|null }}
  */
-export function normalizeSymbol(row, db, hashCache) {
-  let fileHash = null;
+export function normalizeSymbol(
+  row: RawSymbolRow,
+  db?: DbHandle | null,
+  hashCache?: Map<string, string | null>,
+): NormalizedSymbol {
+  let fileHash: string | null = null;
   if (db) {
     if (hashCache) {
       if (!hashCache.has(row.file)) {
         hashCache.set(row.file, getFileHash(db, row.file));
       }
-      fileHash = hashCache.get(row.file);
+      fileHash = hashCache.get(row.file) ?? null;
     } else {
       fileHash = getFileHash(db, row.file);
     }

package/src/shared/{paginate.js → paginate.ts}

@@ -5,8 +5,26 @@
  * change between pages; offset/limit is simpler and maps directly to SQL.
  */
 
+export interface PaginationMeta {
+  total: number;
+  offset: number;
+  limit: number;
+  hasMore: boolean;
+  returned: number;
+}
+
+export interface PaginatedResult<T> {
+  items: T[];
+  pagination?: PaginationMeta;
+}
+
+export interface PaginateOpts {
+  limit?: number;
+  offset?: number;
+}
+
 /** Default limits applied by MCP tool handlers (not by the programmatic API). */
-export const MCP_DEFAULTS = {
+export const MCP_DEFAULTS: Record<string, number> = {
   list_functions: 100,
   query: 10,
   where: 50,
@@ -33,10 +51,8 @@ export const MCP_DEFAULTS = {
 
 /**
  * Get MCP page-size defaults, optionally merged with config overrides.
- * @param {object} [configDefaults] - Override map from config.mcp.defaults
- * @returns {object}
  */
-export function getMcpDefaults(configDefaults) {
+export function getMcpDefaults(configDefaults?: Record<string, number>): Record<string, number> {
   if (!configDefaults) return MCP_DEFAULTS;
   return { ...MCP_DEFAULTS, ...configDefaults };
 }
@@ -48,12 +64,8 @@ export const MCP_MAX_LIMIT = 1000;
  * Paginate an array.
  *
  * When `limit` is undefined the input is returned unchanged (no-op).
- *
- * @param {any[]} items
- * @param {{ limit?: number, offset?: number }} opts
- * @returns {{ items: any[], pagination?: { total: number, offset: number, limit: number, hasMore: boolean, returned: number } }}
  */
-export function paginate(items, { limit, offset } = {}) {
+export function paginate<T>(items: T[], { limit, offset }: PaginateOpts = {}): PaginatedResult<T> {
   if (limit === undefined) {
     return { items };
   }
@@ -78,13 +90,12 @@ export function paginate(items, { limit, offset } = {}) {
  *
  * When `limit` is undefined the result is returned unchanged (backward compat).
  * When active, `_pagination` metadata is added to the result.
- *
- * @param {object} result - The result object (e.g. `{ count: 42, functions: [...] }`)
- * @param {string} field  - The array field name to paginate (e.g. `'functions'`)
- * @param {{ limit?: number, offset?: number }} opts
- * @returns {object} - Result with paginated field + `_pagination` (if active)
  */
-export function paginateResult(result, field, { limit, offset } = {}) {
+export function paginateResult<T extends Record<string, unknown>>(
+  result: T,
+  field: string,
+  { limit, offset }: PaginateOpts = {},
+): T & { _pagination?: PaginationMeta } {
   if (limit === undefined) {
     return result;
   }
@@ -100,11 +111,11 @@ export function paginateResult(result, field, { limit, offset } = {}) {
  *
  * Emits a `_meta` line with pagination info (if present), then one JSON
  * line per item in the named array field.
- *
- * @param {object} data   - Result object (may contain `_pagination`)
- * @param {string} field  - Array field name to stream (e.g. `'results'`)
  */
-export function printNdjson(data, field) {
+export function printNdjson(
+  data: Record<string, unknown> & { _pagination?: PaginationMeta },
+  field: string,
+): void {
   if (data._pagination) console.log(JSON.stringify({ _meta: data._pagination }));
   const items = data[field];
   if (Array.isArray(items)) {

package/src/shared/version.ts

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const __sharedDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
+
+export const CODEGRAPH_VERSION: string = (
+  JSON.parse(fs.readFileSync(path.join(__sharedDir, '..', '..', 'package.json'), 'utf-8')) as {
+    version: string;
+  }
+).version;