@mars167/git-ai 2.3.0

package/dist/src/core/indexing/parallel.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParallelIndexing = runParallelIndexing;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const snapshotParser_1 = require("../dsr/snapshotParser");
+const embedding_1 = require("../embedding");
+const sq8_1 = require("../sq8");
+const crypto_1 = require("../crypto");
+const paths_1 = require("../paths");
+const monitor_1 = require("./monitor");
+async function runParallelIndexing(options) {
+    const parser = new snapshotParser_1.SnapshotCodeParser();
+    const monitor = monitor_1.MemoryMonitor.fromErrorConfig(options.errorHandling, options.indexing.memoryBudgetMb);
+    const pendingFiles = options.files.slice();
+    const totalFiles = pendingFiles.length;
+    let processedFiles = 0;
+    let workerCount = Math.max(1, options.indexing.workerCount);
+    const batchSize = Math.max(1, options.indexing.batchSize);
+    const state = {
+        chunkRowsByLang: {},
+        refRowsByLang: {},
+        astFiles: [],
+        astSymbols: [],
+        astContains: [],
+        astExtendsName: [],
+        astImplementsName: [],
+        astRefsName: [],
+        astCallsName: [],
+    };
+    const runBatch = async (batchFiles) => {
+        const queue = batchFiles.slice();
+        const active = new Set();
+        const scheduleNext = () => {
+            while (active.size < workerCount && queue.length > 0) {
+                const file = queue.shift();
+                if (!file)
+                    break;
+                const task = processFile(file).catch(() => undefined).then(() => {
+                    active.delete(task);
+                });
+                active.add(task);
+            }
+        };
+        scheduleNext();
+        while (active.size > 0) {
+            await Promise.race(active);
+            scheduleNext();
+        }
+    };
+    const processFile = async (file) => {
+        processedFiles++;
+        const filePosix = (0, paths_1.toPosixPath)(file);
+        options.onProgress?.({ totalFiles, processedFiles, currentFile: filePosix });
+        await monitor.throttleIfNeeded();
+        const lang = inferIndexLang(filePosix);
+        if (!state.chunkRowsByLang[lang])
+            state.chunkRowsByLang[lang] = [];
+        if (!state.refRowsByLang[lang])
+            state.refRowsByLang[lang] = [];
+        if (!options.existingChunkIdsByLang[lang])
+            options.existingChunkIdsByLang[lang] = new Set();
+        const fullPath = path_1.default.join(options.scanRoot, file);
+        const stat = await safeStat(fullPath);
+        if (!stat?.isFile())
+            return;
+        const content = await readFileWithGate(fullPath, options.errorHandling);
+        if (content == null)
+            return;
+        const parsed = parseWithFallback(parser, content, fullPath, options.errorHandling);
+        const symbols = parsed.symbols;
+        const fileRefs = parsed.refs;
+        const fileId = (0, crypto_1.sha256Hex)(`file:${filePosix}`);
+        state.astFiles.push([fileId, filePosix, lang]);
+        const callableScopes = [];
+        for (const s of symbols) {
+            const text = buildChunkText(filePosix, s);
+            const contentHash = (0, crypto_1.sha256Hex)(text);
+            const refId = (0, crypto_1.sha256Hex)(`${filePosix}:${s.name}:${s.kind}:${s.startLine}:${s.endLine}:${contentHash}`);
+            state.astSymbols.push([refId, filePosix, lang, s.name, s.kind, s.signature, s.startLine, s.endLine]);
+            if (s.kind === 'function' || s.kind === 'method') {
+                callableScopes.push({ refId, startLine: s.startLine, endLine: s.endLine });
+            }
+            let parentId = fileId;
+            if (s.container) {
+                const cText = buildChunkText(filePosix, s.container);
+                const cHash = (0, crypto_1.sha256Hex)(cText);
+                parentId = (0, crypto_1.sha256Hex)(`${filePosix}:${s.container.name}:${s.container.kind}:${s.container.startLine}:${s.container.endLine}:${cHash}`);
+            }
+            state.astContains.push([parentId, refId]);
+            if (s.kind === 'class') {
+                if (s.extends) {
+                    for (const superName of s.extends)
+                        state.astExtendsName.push([refId, superName]);
+                }
+                if (s.implements) {
+                    for (const ifaceName of s.implements)
+                        state.astImplementsName.push([refId, ifaceName]);
+                }
+            }
+            const existingChunkIds = options.existingChunkIdsByLang[lang];
+            if (!existingChunkIds.has(contentHash)) {
+                const vec = (0, embedding_1.hashEmbedding)(text, { dim: options.dim });
+                const q = (0, sq8_1.quantizeSQ8)(vec, options.indexing.hnswConfig.quantizationBits);
+                state.chunkRowsByLang[lang].push({
+                    content_hash: contentHash,
+                    text,
+                    dim: q.dim,
+                    scale: q.scale,
+                    qvec_b64: Buffer.from(q.q).toString('base64'),
+                });
+                existingChunkIds.add(contentHash);
+            }
+            state.refRowsByLang[lang].push({
+                ref_id: refId,
+                content_hash: contentHash,
+                file: filePosix,
+                symbol: s.name,
+                kind: s.kind,
+                signature: s.signature,
+                start_line: s.startLine,
+                end_line: s.endLine,
+            });
+        }
+        const pickScope = (line) => {
+            let best = null;
+            for (const s of callableScopes) {
+                if (line < s.startLine || line > s.endLine)
+                    continue;
+                const span = s.endLine - s.startLine;
+                if (!best || span < best.span)
+                    best = { refId: s.refId, span };
+            }
+            return best ? best.refId : fileId;
+        };
+        for (const r of fileRefs) {
+            const fromId = pickScope(r.line);
+            state.astRefsName.push([fromId, lang, r.name, r.refKind, filePosix, r.line, r.column]);
+            if (r.refKind === 'call' || r.refKind === 'new') {
+                state.astCallsName.push([fromId, lang, r.name, filePosix, r.line, r.column]);
+            }
+        }
+        const snapshot = monitor.sample();
+        workerCount = monitor.adaptWorkerCount(workerCount);
+        if (snapshot.critical && workerCount <= 1) {
+            options.onThrottle?.({ rssMb: snapshot.rssMb, usageRatio: snapshot.usageRatio });
+            await monitor.throttleIfNeeded();
+        }
+    };
+    options.onProgress?.({ totalFiles, processedFiles: 0 });
+    while (pendingFiles.length > 0) {
+        const batch = pendingFiles.splice(0, batchSize);
+        await runBatch(batch);
+    }
+    return state;
+}
+async function safeStat(filePath) {
+    try {
+        return await fs_extra_1.default.stat(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+async function readFileWithGate(filePath, config) {
+    try {
+        const stat = await fs_extra_1.default.stat(filePath);
+        if (!stat.isFile())
+            return null;
+        if (stat.size > config.largeFileThreshold) {
+            return readLargeFile(filePath, config.maxChunkSize);
+        }
+        return await fs_extra_1.default.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+async function readLargeFile(filePath, maxChars) {
+    const buf = await fs_extra_1.default.readFile(filePath, 'utf-8');
+    if (buf.length <= maxChars)
+        return buf;
+    return buf.slice(0, maxChars);
+}
+function parseWithFallback(parser, content, filePath, config) {
+    try {
+        const result = parser.parseContent(filePath, content);
+        // If parser returned empty results and fallback is configured, use fallback
+        if (result.symbols.length === 0 && result.refs.length === 0) {
+            return fallbackParse(content, filePath, config);
+        }
+        return result;
+    }
+    catch {
+        return fallbackParse(content, filePath, config);
+    }
+}
+function fallbackParse(content, filePath, config) {
+    if (config.parseFailureFallback === 'skip')
+        return { symbols: [], refs: [] };
+    if (config.parseFailureFallback === 'text-only') {
+        return { symbols: buildTextOnlySymbols(content, filePath), refs: [] };
+    }
+    if (config.parseFailureFallback === 'line-chunk') {
+        return { symbols: buildLineChunkSymbols(content, filePath, config.maxChunkSize), refs: [] };
+    }
+    return { symbols: [], refs: [] };
+}
+function buildTextOnlySymbols(content, filePath) {
+    const lines = content.split(/\r?\n/);
+    const name = path_1.default.basename(filePath);
+    return [{ name, kind: 'document', startLine: 1, endLine: Math.max(1, lines.length), signature: name }];
+}
+function buildLineChunkSymbols(content, filePath, maxChunkSize) {
+    const lines = content.split(/\r?\n/);
+    const chunkSize = Math.max(50, Math.min(Math.floor(maxChunkSize / 10), 500));
+    const out = [];
+    for (let i = 0; i < lines.length; i += chunkSize) {
+        const start = i + 1;
+        const end = Math.min(lines.length, i + chunkSize);
+        const name = `${path_1.default.basename(filePath)}:${start}-${end}`;
+        out.push({ name, kind: 'document', startLine: start, endLine: end, signature: name });
+    }
+    if (out.length === 0) {
+        const name = path_1.default.basename(filePath);
+        out.push({ name, kind: 'document', startLine: 1, endLine: Math.max(1, lines.length), signature: name });
+    }
+    return out;
+}
+function buildChunkText(file, symbol) {
+    return `file:${file}\nkind:${symbol.kind}\nname:${symbol.name}\nsignature:${symbol.signature}`;
+}
+function inferIndexLang(file) {
+    if (file.endsWith('.md') || file.endsWith('.mdx'))
+        return 'markdown';
+    if (file.endsWith('.yml') || file.endsWith('.yaml'))
+        return 'yaml';
+    if (file.endsWith('.java'))
+        return 'java';
+    if (file.endsWith('.c') || file.endsWith('.h'))
+        return 'c';
+    if (file.endsWith('.go'))
+        return 'go';
+    if (file.endsWith('.py'))
+        return 'python';
+    if (file.endsWith('.rs'))
+        return 'rust';
+    return 'ts';
+}

package/dist/src/core/lancedb.js

@@ -0,0 +1,111 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_INDEX_LANGS = void 0;
+exports.openTablesByLang = openTablesByLang;
+exports.defaultDbDir = defaultDbDir;
+const lancedb = __importStar(require("@lancedb/lancedb"));
+const apache_arrow_1 = require("apache-arrow");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+exports.ALL_INDEX_LANGS = ['java', 'ts', 'c', 'go', 'python', 'rust', 'markdown', 'yaml'];
+function chunksSchema(dim) {
+    return new apache_arrow_1.Schema([
+        new apache_arrow_1.Field('content_hash', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('text', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('dim', new apache_arrow_1.Int32(), false),
+        new apache_arrow_1.Field('scale', new apache_arrow_1.Float32(), false),
+        new apache_arrow_1.Field('qvec_b64', new apache_arrow_1.Utf8(), false),
+    ]);
+}
+function refsSchema() {
+    return new apache_arrow_1.Schema([
+        new apache_arrow_1.Field('ref_id', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('content_hash', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('file', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('symbol', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('kind', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('signature', new apache_arrow_1.Utf8(), false),
+        new apache_arrow_1.Field('start_line', new apache_arrow_1.Int32(), false),
+        new apache_arrow_1.Field('end_line', new apache_arrow_1.Int32(), false),
+    ]);
+}
+async function openOrCreateTable(db, name, schema, mode) {
+    const tables = await db.tableNames();
+    const exists = tables.includes(name);
+    if (mode === 'open_only') {
+        if (!exists)
+            throw new Error(`LanceDB table not found: ${name}`);
+        return db.openTable(name);
+    }
+    if (mode === 'overwrite') {
+        if (exists)
+            await db.dropTable(name);
+        return db.createEmptyTable(name, schema);
+    }
+    if (exists)
+        return db.openTable(name);
+    return db.createEmptyTable(name, schema);
+}
+function chunksTableName(lang) {
+    return `chunks_${lang}`;
+}
+function refsTableName(lang) {
+    return `refs_${lang}`;
+}
+async function openTablesByLang(options) {
+    if (options.mode === 'open_only') {
+        const exists = await fs_extra_1.default.pathExists(options.dbDir);
+        if (!exists)
+            throw new Error(`LanceDB directory not found: ${options.dbDir}`);
+    }
+    else {
+        await fs_extra_1.default.ensureDir(options.dbDir);
+    }
+    const db = await lancedb.connect(options.dbDir);
+    const byLang = {};
+    for (const lang of options.languages) {
+        const chunks = await openOrCreateTable(db, chunksTableName(lang), chunksSchema(options.dim), options.mode);
+        const refs = await openOrCreateTable(db, refsTableName(lang), refsSchema(), options.mode);
+        byLang[lang] = { lang, chunks, refs };
+    }
+    return { db, byLang };
+}
+function defaultDbDir(repoRoot) {
+    return path_1.default.join(repoRoot, '.git-ai', 'lancedb');
+}

package/dist/src/core/lfs.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGitLfsInstalled = isGitLfsInstalled;
+exports.ensureLfsTracking = ensureLfsTracking;
+const child_process_1 = require("child_process");
+function runGit(args, cwd) {
+    const res = (0, child_process_1.spawnSync)('git', args, { cwd, stdio: 'inherit' });
+    if (res.status !== 0)
+        throw new Error(`git ${args.join(' ')} failed`);
+}
+function isGitRepo(cwd) {
+    const res = (0, child_process_1.spawnSync)('git', ['rev-parse', '--show-toplevel'], { cwd, stdio: 'ignore' });
+    return res.status === 0;
+}
+function isGitLfsInstalled(cwd) {
+    if (!isGitRepo(cwd))
+        return false;
+    const res = (0, child_process_1.spawnSync)('git', ['lfs', 'version'], { cwd, stdio: 'ignore' });
+    return res.status === 0;
+}
+function ensureLfsTracking(cwd, pattern) {
+    if (!isGitLfsInstalled(cwd))
+        return { tracked: false };
+    runGit(['lfs', 'track', pattern], cwd);
+    runGit(['add', '.gitattributes'], cwd);
+    return { tracked: true };
+}

package/dist/src/core/log.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const levelOrder = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+function getConfiguredLevel() {
+    const raw = String(process.env.GIT_AI_LOG_LEVEL ?? process.env.LOG_LEVEL ?? '').trim().toLowerCase();
+    if (!raw)
+        return 'info';
+    if (raw === 'silent' || raw === 'off' || raw === 'none' || raw === '0')
+        return null;
+    if (raw === 'debug' || raw === 'info' || raw === 'warn' || raw === 'error')
+        return raw;
+    return 'info';
+}
+function serializeError(e) {
+    if (!e)
+        return undefined;
+    if (e instanceof Error)
+        return { name: e.name, message: e.message, stack: e.stack };
+    return { message: String(e) };
+}
+function createLogger(baseFields = {}) {
+    const configured = getConfiguredLevel();
+    const threshold = configured ? levelOrder[configured] : Infinity;
+    const write = (level, msg, fields) => {
+        if (levelOrder[level] < threshold)
+            return;
+        const rec = {
+            ts: new Date().toISOString(),
+            level,
+            msg,
+            ...baseFields,
+            ...(fields ?? {}),
+        };
+        process.stderr.write(JSON.stringify(rec) + '\n');
+    };
+    const logger = {
+        debug: (msg, fields) => write('debug', msg, fields),
+        info: (msg, fields) => write('info', msg, fields),
+        warn: (msg, fields) => write('warn', msg, fields),
+        error: (msg, fields) => write('error', msg, fields),
+        child: (fields) => createLogger({ ...baseFields, ...fields }),
+        span: async (name, fields, fn) => {
+            const startedAt = Date.now();
+            try {
+                const out = await fn();
+                write('info', name, { ...fields, ok: true, duration_ms: Date.now() - startedAt });
+                return out;
+            }
+            catch (e) {
+                write('error', name, { ...fields, ok: false, duration_ms: Date.now() - startedAt, err: serializeError(e) });
+                throw e;
+            }
+        },
+    };
+    return logger;
+}

package/dist/src/core/manifest.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRepoManifestXml = parseRepoManifestXml;
+exports.loadRepoManifestFromManifestsRepo = loadRepoManifestFromManifestsRepo;
+exports.resolveProjectRevision = resolveProjectRevision;
+exports.resolveProjectFetch = resolveProjectFetch;
+exports.buildCloneUrl = buildCloneUrl;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const glob_1 = require("glob");
+function parseAttributes(raw) {
+    const attrs = {};
+    const re = /(\w+)\s*=\s*"([^"]*)"/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        attrs[m[1]] = m[2];
+    }
+    return attrs;
+}
+function parseRepoManifestXml(xml) {
+    const remotes = {};
+    const projects = [];
+    let defaultRemote;
+    let defaultRevision;
+    for (const m of xml.matchAll(/<remote\b([^>]*?)\/>/g)) {
+        const attrs = parseAttributes(m[1] ?? '');
+        if (attrs.name) {
+            remotes[attrs.name] = { fetch: attrs.fetch };
+        }
+    }
+    for (const m of xml.matchAll(/<default\b([^>]*?)\/>/g)) {
+        const attrs = parseAttributes(m[1] ?? '');
+        if (attrs.remote)
+            defaultRemote = attrs.remote;
+        if (attrs.revision)
+            defaultRevision = attrs.revision;
+    }
+    for (const m of xml.matchAll(/<project\b([^>]*?)(?:\/>|>)/g)) {
+        const attrs = parseAttributes(m[1] ?? '');
+        if (!attrs.name)
+            continue;
+        projects.push({
+            name: attrs.name,
+            path: attrs.path ?? attrs.name,
+            remote: attrs.remote,
+            revision: attrs.revision,
+        });
+    }
+    return { defaultRemote, defaultRevision, remotes, projects };
+}
+async function loadRepoManifestFromManifestsRepo(repoRoot) {
+    const defaultXml = path_1.default.join(repoRoot, 'default.xml');
+    if (await fs_extra_1.default.pathExists(defaultXml)) {
+        const xml = await fs_extra_1.default.readFile(defaultXml, 'utf-8');
+        return parseRepoManifestXml(xml);
+    }
+    const xmlFiles = await (0, glob_1.glob)('*.xml', { cwd: repoRoot, nodir: true });
+    for (const f of xmlFiles) {
+        const xml = await fs_extra_1.default.readFile(path_1.default.join(repoRoot, f), 'utf-8');
+        const parsed = parseRepoManifestXml(xml);
+        if (parsed.projects.length > 0)
+            return parsed;
+    }
+    return { remotes: {}, projects: [] };
+}
+function resolveProjectRevision(project, manifest) {
+    return project.revision ?? manifest.defaultRevision;
+}
+function resolveProjectFetch(project, manifest) {
+    const remoteName = project.remote ?? manifest.defaultRemote;
+    return remoteName ? manifest.remotes[remoteName]?.fetch : undefined;
+}
+function buildCloneUrl(fetch, projectName) {
+    const base = String(fetch).trim();
+    if (base.includes('://')) {
+        return base.endsWith('/') ? `${base}${projectName}` : `${base}/${projectName}`;
+    }
+    if (base.includes(':')) {
+        const idx = base.indexOf(':');
+        const left = base.slice(0, idx + 1);
+        const right = base.slice(idx + 1).replace(/\/+$/, '');
+        return `${left}${right}/${projectName}`;
+    }
+    return base.endsWith('/') ? `${base}${projectName}` : `${base}/${projectName}`;
+}

package/dist/src/core/parser/adapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/parser/c.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAdapter = void 0;
+const tree_sitter_c_1 = __importDefault(require("tree-sitter-c"));
+const utils_1 = require("./utils");
+class CAdapter {
+    getLanguageId() {
+        return 'c';
+    }
+    getTreeSitterLanguage() {
+        return tree_sitter_c_1.default;
+    }
+    getSupportedFileExtensions() {
+        return ['.c', '.h'];
+    }
+    extractSymbolsAndRefs(node) {
+        const symbols = [];
+        const refs = [];
+        const traverse = (n, container) => {
+            if (n.type === 'call_expression') {
+                const fn = n.childForFieldName('function');
+                if (fn)
+                    (0, utils_1.pushRef)(refs, fn.text, 'call', fn);
+            }
+            else if (n.type === 'type_identifier') {
+                (0, utils_1.pushRef)(refs, n.text, 'type', n);
+            }
+            let currentContainer = container;
+            if (n.type === 'function_definition') {
+                const declarator = n.childForFieldName('declarator');
+                const nameNode = this.findIdentifier(declarator);
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'function',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: this.getSignature(n),
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            else if (n.type === 'struct_specifier') {
+                const nameNode = n.childForFieldName('name');
+                if (nameNode) {
+                    const newSymbol = {
+                        name: nameNode.text,
+                        kind: 'class',
+                        startLine: n.startPosition.row + 1,
+                        endLine: n.endPosition.row + 1,
+                        signature: `struct ${nameNode.text}`,
+                        container: container,
+                    };
+                    symbols.push(newSymbol);
+                    currentContainer = newSymbol;
+                }
+            }
+            for (let i = 0; i < n.childCount; i++)
+                traverse(n.child(i), currentContainer);
+        };
+        traverse(node, undefined);
+        return { symbols, refs };
+    }
+    findIdentifier(node) {
+        if (!node)
+            return null;
+        if (node.type === 'identifier')
+            return node;
+        // recursive search, but limit depth or prioritize 'declarator' fields?
+        // In C, function_declarator has 'declarator' field.
+        if (node.type === 'function_declarator' || node.type === 'pointer_declarator' || node.type === 'parenthesized_declarator') {
+            const decl = node.childForFieldName('declarator');
+            if (decl)
+                return this.findIdentifier(decl);
+            // if no named field, just check children
+            for (let i = 0; i < node.childCount; i++) {
+                const res = this.findIdentifier(node.child(i));
+                if (res)
+                    return res;
+            }
+        }
+        return null;
+    }
+    getSignature(node) {
+        return node.text.split('{')[0].trim();
+    }
+}
+exports.CAdapter = CAdapter;