@mars167/git-ai 2.3.0

package/dist/src/core/repoMap.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRepoMap = generateRepoMap;
+exports.formatRepoMap = formatRepoMap;
+const astGraphQuery_1 = require("./astGraphQuery");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function generateRepoMap(options) {
+    const { repoRoot, maxFiles = 20, maxSymbolsPerFile = 5, wikiDir } = options;
+    const symbolsQuery = `?[ref_id, file, name, kind, signature, start_line, end_line] := *ast_symbol{ref_id, file, name, kind, signature, start_line, end_line}`;
+    const symbolsRes = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, symbolsQuery);
+    const symbolsRaw = Array.isArray(symbolsRes?.rows) ? symbolsRes.rows : [];
+    const symbolMap = new Map();
+    for (const row of symbolsRaw) {
+        symbolMap.set(row[0], {
+            id: row[0],
+            file: row[1],
+            name: row[2],
+            kind: row[3],
+            signature: row[4],
+            start_line: row[5],
+            end_line: row[6],
+            inDegree: 0,
+            outEdges: new Set(),
+        });
+    }
+    const relationsQuery = `
+    ?[from_id, to_id] := *ast_call_name{caller_id: from_id, callee_name: name}, *ast_symbol{ref_id: to_id, name}
+    ?[from_id, to_id] := *ast_ref_name{from_id, name}, *ast_symbol{ref_id: to_id, name}
+  `;
+    const relationsRes = await (0, astGraphQuery_1.runAstGraphQuery)(repoRoot, relationsQuery);
+    const relationsRaw = Array.isArray(relationsRes?.rows) ? relationsRes.rows : [];
+    for (const [fromId, toId] of relationsRaw) {
+        if (symbolMap.has(fromId) && symbolMap.has(toId) && fromId !== toId) {
+            const fromNode = symbolMap.get(fromId);
+            const toNode = symbolMap.get(toId);
+            if (!fromNode.outEdges.has(toId)) {
+                fromNode.outEdges.add(toId);
+                toNode.inDegree += 1;
+            }
+        }
+    }
+    const nodes = Array.from(symbolMap.values());
+    const N = nodes.length;
+    if (N === 0)
+        return [];
+    let ranks = new Map();
+    nodes.forEach(n => ranks.set(n.id, 1 / N));
+    const damping = 0.85;
+    const iterations = 10;
+    for (let i = 0; i < iterations; i++) {
+        const newRanks = new Map();
+        nodes.forEach(n => newRanks.set(n.id, (1 - damping) / N));
+        for (const node of nodes) {
+            const currentRank = ranks.get(node.id);
+            if (node.outEdges.size > 0) {
+                const share = (currentRank * damping) / node.outEdges.size;
+                for (const targetId of node.outEdges) {
+                    newRanks.set(targetId, newRanks.get(targetId) + share);
+                }
+            }
+            else {
+                const share = (currentRank * damping) / N;
+                for (const n2 of nodes) {
+                    newRanks.set(n2.id, newRanks.get(n2.id) + share);
+                }
+            }
+        }
+        ranks = newRanks;
+    }
+    const fileMap = new Map();
+    for (const node of nodes) {
+        const rank = ranks.get(node.id);
+        if (!fileMap.has(node.file)) {
+            fileMap.set(node.file, { rank: 0, symbols: [] });
+        }
+        const fileInfo = fileMap.get(node.file);
+        fileInfo.rank += rank;
+        fileInfo.symbols.push({
+            id: node.id,
+            name: node.name,
+            kind: node.kind,
+            file: node.file,
+            rank: rank,
+            signature: node.signature,
+            start_line: node.start_line,
+            end_line: node.end_line,
+        });
+    }
+    let wikiPages = [];
+    if (wikiDir && fs_extra_1.default.existsSync(wikiDir)) {
+        const files = fs_extra_1.default.readdirSync(wikiDir).filter(f => f.endsWith('.md') && f !== 'index.md');
+        wikiPages = files.map(f => ({
+            file: f,
+            content: fs_extra_1.default.readFileSync(path_1.default.join(wikiDir, f), 'utf8').toLowerCase(),
+        }));
+    }
+    const result = Array.from(fileMap.entries())
+        .map(([filePath, info]) => {
+        const sortedSymbols = info.symbols
+            .sort((a, b) => b.rank - a.rank)
+            .slice(0, maxSymbolsPerFile);
+        let wikiLink;
+        const baseName = path_1.default.basename(filePath, path_1.default.extname(filePath)).toLowerCase();
+        const matchedByFile = wikiPages.find(p => p.file.toLowerCase().includes(baseName));
+        if (matchedByFile) {
+            wikiLink = matchedByFile.file;
+        }
+        else {
+            const mentioner = wikiPages.find(p => p.content.includes(baseName) ||
+                sortedSymbols.some(s => s.name.length > 3 && p.content.includes(s.name.toLowerCase())));
+            if (mentioner) {
+                wikiLink = mentioner.file;
+            }
+        }
+        return {
+            path: filePath,
+            rank: info.rank,
+            symbols: sortedSymbols,
+            wikiLink,
+        };
+    })
+        .sort((a, b) => b.rank - a.rank)
+        .slice(0, maxFiles);
+    return result;
+}
+function formatRepoMap(fileRanks) {
+    if (fileRanks.length === 0)
+        return 'No symbols found to map.';
+    let output = 'Repository Map (ranked by importance)\n';
+    output += '====================================\n\n';
+    for (const file of fileRanks) {
+        output += `${file.path} (score: ${(file.rank * 100).toFixed(2)})\n`;
+        if (file.wikiLink) {
+            output += `   wiki: ${file.wikiLink}\n`;
+        }
+        for (const sym of file.symbols) {
+            const indent = '   ';
+            const kindIcon = getKindIcon(sym.kind);
+            output += `${indent}${kindIcon} ${sym.name} [L${sym.start_line}]\n`;
+        }
+        output += '\n';
+    }
+    return output;
+}
+function getKindIcon(kind) {
+    switch (kind.toLowerCase()) {
+        case 'function':
+        case 'method':
+            return 'ƒ';
+        case 'class':
+            return '©';
+        case 'interface':
+            return 'ɪ';
+        case 'variable':
+        case 'constant':
+            return 'ν';
+        default:
+            return '•';
+    }
+}

package/dist/src/core/retrieval/cache.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruCache = void 0;
+class LruCache {
+    constructor(maxSize) {
+        this.maxSize = Math.max(1, maxSize);
+        this.map = new Map();
+    }
+    get(key) {
+        const value = this.map.get(key);
+        if (!value)
+            return undefined;
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (this.map.has(key))
+            this.map.delete(key);
+        this.map.set(key, value);
+        if (this.map.size > this.maxSize) {
+            const first = this.map.keys().next().value;
+            if (first)
+                this.map.delete(first);
+        }
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+exports.LruCache = LruCache;

package/dist/src/core/retrieval/classifier.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyQuery = classifyQuery;
+const STRUCTURAL_HINTS = ['callers', 'callees', 'call chain', 'inherit', 'extends', 'implements', 'graph', 'references', 'refs', 'ast'];
+const HISTORICAL_HINTS = ['history', 'commit', 'diff', 'changed', 'evolution', 'dsr', 'timeline', 'version', 'previous'];
+const SYMBOL_HINTS = ['function', 'class', 'method', 'symbol', 'identifier'];
+const FILE_PATTERN = /(\S+\.(?:ts|tsx|js|jsx|java|py|go|rs|c|h|md|mdx|yaml|yml))/i;
+const SYMBOL_PATTERN = /\b([A-Za-z_][A-Za-z0-9_$.]*)\b/g;
+function scoreHints(query, hints) {
+    const q = query.toLowerCase();
+    let score = 0;
+    for (const h of hints) {
+        if (q.includes(h))
+            score += 1;
+    }
+    return score;
+}
+function extractEntities(query) {
+    const entities = [];
+    const fileMatch = query.match(FILE_PATTERN);
+    if (fileMatch?.[1]) {
+        entities.push({ type: 'file', value: fileMatch[1], confidence: 0.8 });
+    }
+    const symbols = new Set();
+    let m;
+    SYMBOL_PATTERN.lastIndex = 0;
+    while ((m = SYMBOL_PATTERN.exec(query)) !== null) {
+        const token = m[1];
+        if (!token)
+            continue;
+        if (token.length < 3)
+            continue;
+        if (/^(the|and|for|with|from|into|over|when|where|what|show)$/i.test(token))
+            continue;
+        symbols.add(token);
+    }
+    for (const s of symbols)
+        entities.push({ type: 'symbol', value: s, confidence: 0.5 });
+    if (symbols.size === 0 && query.trim()) {
+        entities.push({ type: 'keyword', value: query.trim(), confidence: 0.3 });
+    }
+    return entities;
+}
+function pickPrimary(scores) {
+    const entries = Object.entries(scores);
+    entries.sort((a, b) => b[1] - a[1]);
+    const top = entries[0];
+    const second = entries[1];
+    if (!top)
+        return { primary: 'semantic', confidence: 0.25 };
+    const confidence = top[1] <= 0 ? 0.25 : Math.min(0.95, 0.4 + top[1] * 0.2 - (second?.[1] ?? 0) * 0.1);
+    return { primary: top[0], confidence };
+}
+function classifyQuery(query) {
+    const q = String(query ?? '').trim();
+    const scores = {
+        semantic: 0.5,
+        structural: scoreHints(q, STRUCTURAL_HINTS),
+        historical: scoreHints(q, HISTORICAL_HINTS),
+        hybrid: 0,
+    };
+    const hasSymbols = scoreHints(q, SYMBOL_HINTS) > 0 || FILE_PATTERN.test(q);
+    if (hasSymbols)
+        scores.structural += 1;
+    if (scores.structural > 0 && scores.historical > 0) {
+        scores.hybrid = Math.max(scores.structural, scores.historical) + 1;
+    }
+    const primary = pickPrimary(scores);
+    return {
+        primary: primary.primary,
+        confidence: primary.confidence,
+        entities: extractEntities(q),
+    };
+}

package/dist/src/core/retrieval/expander.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandQuery = expandQuery;
+const ABBREVIATIONS = {
+    cfg: 'configuration',
+    auth: 'authentication',
+    repo: 'repository',
+    svc: 'service',
+    impl: 'implementation',
+    dep: 'dependency',
+    deps: 'dependencies',
+    doc: 'documentation',
+    docs: 'documentation',
+    api: 'interface',
+    ui: 'user interface',
+    ux: 'user experience',
+};
+const SYNONYMS = {
+    bug: ['issue', 'error', 'fault'],
+    fix: ['resolve', 'repair', 'patch'],
+    config: ['configuration', 'settings'],
+    search: ['lookup', 'find', 'query'],
+    history: ['timeline', 'evolution', 'past'],
+    commit: ['revision', 'changeset'],
+    graph: ['relations', 'edges', 'call graph'],
+    symbol: ['identifier', 'name'],
+};
+const DOMAIN_VOCAB = {
+    dsr: ['deterministic semantic record', 'semantic snapshot'],
+    lancedb: ['vector database', 'lance db'],
+    cozo: ['graph database', 'cozodb'],
+    ast: ['syntax tree', 'abstract syntax tree'],
+};
+function tokenize(query) {
+    return String(query ?? '')
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/g)
+        .map((t) => t.trim())
+        .filter(Boolean);
+}
+function expandToken(token) {
+    const expansions = new Set();
+    expansions.add(token);
+    const abbr = ABBREVIATIONS[token];
+    if (abbr)
+        expansions.add(abbr);
+    const syns = SYNONYMS[token];
+    if (syns)
+        syns.forEach((s) => expansions.add(s));
+    const domain = DOMAIN_VOCAB[token];
+    if (domain)
+        domain.forEach((s) => expansions.add(s));
+    return Array.from(expansions);
+}
+function buildExpansion(query) {
+    const tokens = tokenize(query);
+    if (tokens.length === 0)
+        return [query];
+    const expandedTokens = tokens.flatMap((t) => expandToken(t));
+    const unique = Array.from(new Set(expandedTokens));
+    return unique.length > 0 ? unique : tokens;
+}
+function expandQuery(query, queryType) {
+    const base = String(query ?? '').trim();
+    if (!base)
+        return [];
+    const expansions = new Set();
+    expansions.add(base);
+    for (const token of buildExpansion(base))
+        expansions.add(token);
+    if (queryType?.primary === 'historical') {
+        expansions.add(`${base} history`);
+        expansions.add(`${base} commit`);
+    }
+    if (queryType?.primary === 'structural') {
+        expansions.add(`${base} graph`);
+        expansions.add(`${base} references`);
+    }
+    return Array.from(expansions).slice(0, 12);
+}

package/dist/src/core/retrieval/fuser.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fuseResults = fuseResults;
+function normalizeScores(candidates) {
+    const bySource = new Map();
+    for (const c of candidates) {
+        if (!bySource.has(c.source))
+            bySource.set(c.source, []);
+        bySource.get(c.source).push(c);
+    }
+    const normalized = new Map();
+    for (const [source, items] of bySource.entries()) {
+        const scores = items.map((i) => i.score);
+        const max = Math.max(...scores, 0.0001);
+        for (const item of items) {
+            normalized.set(`${source}:${item.id}`, item.score / max);
+        }
+    }
+    return normalized;
+}
+function fuseResults(candidates, weights, limit = 50) {
+    if (!Array.isArray(candidates) || candidates.length === 0)
+        return [];
+    const normalized = normalizeScores(candidates);
+    const out = candidates.map((c) => {
+        const key = `${c.source}:${c.id}`;
+        const normalizedScore = normalized.get(key) ?? 0;
+        const weight = c.source === 'vector'
+            ? weights.vectorWeight
+            : c.source === 'graph'
+                ? weights.graphWeight
+                : c.source === 'dsr'
+                    ? weights.dsrWeight
+                    : weights.symbolWeight;
+        const fusedScore = normalizedScore * weight;
+        return { ...c, normalizedScore, fusedScore, rank: 0 };
+    });
+    out.sort((a, b) => b.fusedScore - a.fusedScore || b.score - a.score);
+    return out.slice(0, limit).map((item, idx) => ({ ...item, rank: idx + 1 }));
+}

package/dist/src/core/retrieval/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruCache = exports.fuseScores = exports.CrossEncoderReranker = exports.rerank = exports.fuseResults = exports.computeWeights = exports.expandQuery = exports.classifyQuery = void 0;
+__exportStar(require("./types"), exports);
+var classifier_1 = require("./classifier");
+Object.defineProperty(exports, "classifyQuery", { enumerable: true, get: function () { return classifier_1.classifyQuery; } });
+var expander_1 = require("./expander");
+Object.defineProperty(exports, "expandQuery", { enumerable: true, get: function () { return expander_1.expandQuery; } });
+var weights_1 = require("./weights");
+Object.defineProperty(exports, "computeWeights", { enumerable: true, get: function () { return weights_1.computeWeights; } });
+var fuser_1 = require("./fuser");
+Object.defineProperty(exports, "fuseResults", { enumerable: true, get: function () { return fuser_1.fuseResults; } });
+var reranker_1 = require("./reranker");
+Object.defineProperty(exports, "rerank", { enumerable: true, get: function () { return reranker_1.rerank; } });
+Object.defineProperty(exports, "CrossEncoderReranker", { enumerable: true, get: function () { return reranker_1.CrossEncoderReranker; } });
+Object.defineProperty(exports, "fuseScores", { enumerable: true, get: function () { return reranker_1.fuseScores; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "LruCache", { enumerable: true, get: function () { return cache_1.LruCache; } });