kodingo-cli 1.0.0

package/dist/adapters/db-adapter/memory-persistence.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDb = initDb;
+exports.checkDatabaseConnection = checkDatabaseConnection;
+exports.saveMemory = saveMemory;
+exports.getMemoryById = getMemoryById;
+exports.updateMemoryLifecycle = updateMemoryLifecycle;
+exports.suppressProposedSiblings = suppressProposedSiblings;
+exports.getMemoryByExternalId = getMemoryByExternalId;
+exports.getProposedOrIgnoredRecordBySymbol = getProposedOrIgnoredRecordBySymbol;
+exports.updateMemoryConfidence = updateMemoryConfidence;
+exports.deleteMemoryById = deleteMemoryById;
+exports.queryMemory = queryMemory;
+exports.queryMemoryBySymbol = queryMemoryBySymbol;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const uuid_1 = require("uuid");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function initDb() {
+    await runPsql(`
+    CREATE TABLE IF NOT EXISTS kodingo_memory (
+      id uuid PRIMARY KEY,
+      type text NOT NULL,
+      title text NULL,
+      content text NOT NULL,
+      tags text[] NULL,
+      repo_path text NULL,
+
+      status text NOT NULL DEFAULT 'proposed',
+      confidence double precision NOT NULL DEFAULT 0.30,
+      symbol text NULL,
+
+      external_id text NULL,
+
+      corrects_id uuid NULL,
+      corrected_by_id uuid NULL,
+
+      created_at timestamptz NOT NULL DEFAULT now()
+    );
+
+    -- Backfill columns (safe on existing installs)
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS status text NOT NULL DEFAULT 'proposed';
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS confidence double precision NOT NULL DEFAULT 0.30;
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS symbol text NULL;
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS external_id text NULL;
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS corrects_id uuid NULL;
+    ALTER TABLE kodingo_memory ADD COLUMN IF NOT EXISTS corrected_by_id uuid NULL;
+
+    -- Indexes
+    CREATE INDEX IF NOT EXISTS kodingo_memory_created_at_idx
+      ON kodingo_memory (created_at);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_repo_path_idx
+      ON kodingo_memory (repo_path);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_status_idx
+      ON kodingo_memory (status);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_symbol_idx
+      ON kodingo_memory (symbol);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_external_id_idx
+      ON kodingo_memory (external_id);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_corrects_id_idx
+      ON kodingo_memory (corrects_id);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_corrected_by_id_idx
+      ON kodingo_memory (corrected_by_id);
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_tags_gin_idx
+      ON kodingo_memory USING GIN (tags);
+
+    -- De-dup per repo + external_id (only when external_id exists)
+    DO $$
+    BEGIN
+      IF NOT EXISTS (
+        SELECT 1
+        FROM pg_indexes
+        WHERE indexname = 'kodingo_memory_repo_external_id_uniq'
+      ) THEN
+        EXECUTE 'CREATE UNIQUE INDEX kodingo_memory_repo_external_id_uniq
+                 ON kodingo_memory (repo_path, external_id)
+                 WHERE external_id IS NOT NULL';
+      END IF;
+    END $$;
+
+    CREATE INDEX IF NOT EXISTS kodingo_memory_content_fts_idx
+      ON kodingo_memory
+      USING GIN (to_tsvector('english', coalesce(title, '') || ' ' || content));
+  `);
+}
+async function checkDatabaseConnection() {
+    await runPsql(`SELECT 1;`);
+}
+async function saveMemory(input) {
+    const id = (0, uuid_1.v4)();
+    const status = input.status ?? "proposed";
+    const confidence = clamp01(input.confidence ?? 0.3);
+    const sql = `
+    WITH inserted AS (
+      INSERT INTO kodingo_memory (
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id
+      )
+      VALUES (
+        ${sqlLiteral(id)},
+        ${sqlLiteral(input.type)},
+        ${sqlNullableLiteral(input.title)},
+        ${sqlLiteral(input.content)},
+        ${sqlArrayLiteral(input.tags)},
+        ${sqlNullableLiteral(input.repoPath)},
+        ${sqlLiteral(status)},
+        ${sqlNumberLiteral(confidence)},
+        ${sqlNullableLiteral(input.symbol)},
+        ${sqlNullableLiteral(input.externalId)},
+        ${sqlNullableUuidLiteral(input.correctsId)},
+        ${sqlNullableUuidLiteral(input.correctedById)}
+      )
+      RETURNING
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+    )
+    SELECT row_to_json(inserted) FROM inserted;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        throw new Error("Failed to insert memory record");
+    return mapRow(row);
+}
+async function getMemoryById(id) {
+    const sql = `
+    SELECT row_to_json(result) FROM (
+      SELECT
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+      FROM kodingo_memory
+      WHERE id = ${sqlLiteral(id)}
+      LIMIT 1
+    ) AS result;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        return null;
+    return mapRow(row);
+}
+async function updateMemoryLifecycle(params) {
+    const correctedByClause = params.correctedById
+        ? `, corrected_by_id = ${sqlNullableUuidLiteral(params.correctedById)}`
+        : "";
+    const sql = `
+    WITH updated AS (
+      UPDATE kodingo_memory
+      SET
+        status = ${sqlLiteral(params.status)},
+        confidence = ${sqlNumberLiteral(clamp01(params.confidence))}
+        ${correctedByClause}
+      WHERE id = ${sqlLiteral(params.id)}
+      RETURNING
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+    )
+    SELECT row_to_json(updated) FROM updated;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        throw new Error(`Memory record not found: ${params.id}`);
+    return mapRow(row);
+}
+/**
+ * Suppress stale proposed siblings for a symbol after affirmation.
+ *
+ * Rule: when a record is affirmed, all other records in the same repo
+ * with the same symbol and status=proposed are marked ignored.
+ * Denied and ignored records are left untouched.
+ */
+async function suppressProposedSiblings(params) {
+    const repoClause = params.repoPath
+        ? `AND repo_path = ${sqlLiteral(params.repoPath)}`
+        : `AND repo_path IS NULL`;
+    const sql = `
+    WITH suppressed AS (
+      UPDATE kodingo_memory
+      SET status = 'ignored'
+      WHERE symbol = ${sqlLiteral(params.symbol)}
+      AND status = 'proposed'
+      AND id <> ${sqlLiteral(params.excludeId)}
+      ${repoClause}
+      RETURNING id
+    )
+    SELECT row_to_json(t) FROM (
+      SELECT count(*)::int AS suppressed_count FROM suppressed
+    ) t;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        return 0;
+    const val = row.suppressed_count;
+    return typeof val === "number" && Number.isFinite(val) ? val : 0;
+}
+/**
+ * Look up a memory record by external_id, scoped to a repo.
+ * Used for idempotency checks in git ingestion.
+ */
+async function getMemoryByExternalId(externalId, repoPath) {
+    const sql = `
+    SELECT row_to_json(result) FROM (
+      SELECT
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+      FROM kodingo_memory
+      WHERE external_id = ${sqlLiteral(externalId)}
+      AND repo_path = ${sqlLiteral(repoPath)}
+      LIMIT 1
+    ) AS result;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        return null;
+    return mapRow(row);
+}
+/**
+ * Find the best proposed or ignored record for a symbol in a repo.
+ * Used for confidence accumulation — signals raise existing records
+ * rather than inserting duplicates.
+ */
+async function getProposedOrIgnoredRecordBySymbol(params) {
+    const sql = `
+    SELECT row_to_json(result) FROM (
+      SELECT
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+      FROM kodingo_memory
+      WHERE symbol = ${sqlLiteral(params.symbol)}
+      AND repo_path = ${sqlLiteral(params.repoPath)}
+      AND status IN ('proposed', 'ignored')
+      ORDER BY
+        (status = 'proposed') DESC,
+        confidence DESC,
+        created_at DESC
+      LIMIT 1
+    ) AS result;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        return null;
+    return mapRow(row);
+}
+/**
+ * Update only the confidence of a memory record.
+ * Used for signal accumulation — does not touch status or any other field.
+ */
+async function updateMemoryConfidence(params) {
+    const sql = `
+    WITH updated AS (
+      UPDATE kodingo_memory
+      SET confidence = ${sqlNumberLiteral(clamp01(params.confidence))}
+      WHERE id = ${sqlLiteral(params.id)}
+      RETURNING
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+    )
+    SELECT row_to_json(updated) FROM updated;
+  `;
+    const rows = await runPsqlRows(sql);
+    const row = rows[0];
+    if (!row)
+        throw new Error(`Memory record not found: ${params.id}`);
+    return mapRow(row);
+}
+async function deleteMemoryById(id) {
+    const sql = `
+    DELETE FROM kodingo_memory
+    WHERE id = ${sqlLiteral(id)};
+  `;
+    await runPsql(sql);
+}
+/**
+ * Text query:
+ * - Full-text search on title/content
+ * - OR exact tag match when user searches for a tag-like token (e.g. "signal:git")
+ *
+ * Options:
+ * - dedupeBySymbol: return only the best record per symbol (DISTINCT ON symbol).
+ *   Records with no symbol are never deduped against each other.
+ * - includeNonCanonical: include denied records in results.
+ *   Default behaviour excludes denied; proposed/ignored are always included.
+ */
+async function queryMemory(text, limit = 10, repoPath, opts = {}) {
+    const safeLimit = Number.isFinite(limit) ? limit : 10;
+    const scopeClause = repoPath ? `AND repo_path = ${sqlLiteral(repoPath)}` : "";
+    const deniedClause = opts.includeNonCanonical ? "" : `AND status <> 'denied'`;
+    const term = (text ?? "").trim();
+    const tagTerm = term;
+    if (opts.dedupeBySymbol) {
+        // DISTINCT ON (symbol) keeps the best row per symbol, ordered canonically.
+        // Rows with NULL symbol are each treated as distinct (no collapse).
+        const sql = `
+      SELECT row_to_json(result) FROM (
+        SELECT DISTINCT ON (coalesce(symbol, id::text))
+          id, type, title, content, tags, repo_path,
+          status, confidence, symbol, external_id,
+          corrects_id, corrected_by_id,
+          created_at
+        FROM kodingo_memory
+        WHERE (
+          to_tsvector('english', coalesce(title, '') || ' ' || content)
+            @@ plainto_tsquery('english', ${sqlLiteral(term)})
+          OR (
+            ${sqlLiteral(tagTerm)} <> ''
+            AND tags IS NOT NULL
+            AND tags @> ARRAY[${sqlLiteral(tagTerm)}]::text[]
+          )
+        )
+        ${scopeClause}
+        ${deniedClause}
+        ORDER BY
+          coalesce(symbol, id::text),
+          (status = 'affirmed') DESC,
+          confidence DESC,
+          created_at DESC
+        LIMIT ${safeLimit}
+      ) AS result;
+    `;
+        const rows = await runPsqlRows(sql);
+        return rows.map((row) => mapRow(row));
+    }
+    // Default: canonical-preferred ranking, no symbol deduplication.
+    const sql = `
+    SELECT row_to_json(result) FROM (
+      SELECT
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at,
+        CASE
+          WHEN to_tsvector('english', coalesce(title, '') || ' ' || content)
+            @@ plainto_tsquery('english', ${sqlLiteral(term)})
+          THEN ts_rank(
+            to_tsvector('english', coalesce(title, '') || ' ' || content),
+            plainto_tsquery('english', ${sqlLiteral(term)})
+          )
+          ELSE 0
+        END AS rank
+      FROM kodingo_memory
+      WHERE (
+        to_tsvector('english', coalesce(title, '') || ' ' || content)
+          @@ plainto_tsquery('english', ${sqlLiteral(term)})
+        OR (
+          ${sqlLiteral(tagTerm)} <> ''
+          AND tags IS NOT NULL
+          AND tags @> ARRAY[${sqlLiteral(tagTerm)}]::text[]
+        )
+      )
+      ${scopeClause}
+      ${deniedClause}
+      ORDER BY
+        (status = 'affirmed') DESC,
+        rank DESC,
+        confidence DESC,
+        created_at DESC
+      LIMIT ${safeLimit}
+    ) AS result;
+  `;
+    const rows = await runPsqlRows(sql);
+    return rows.map((row) => mapRow(row));
+}
+/**
+ * Symbol query with canonical preference.
+ *
+ * Default behavior (when onlyCanonical=false and includeDenied=false):
+ * - Prefer affirmed first
+ * - Then proposed/ignored
+ * - Exclude denied
+ */
+async function queryMemoryBySymbol(params) {
+    const safeLimit = Number.isFinite(params.limit ?? 10)
+        ? (params.limit ?? 10)
+        : 10;
+    const scopeClause = params.repoPath
+        ? `AND repo_path = ${sqlLiteral(params.repoPath)}`
+        : "";
+    let statusClause = "";
+    if (params.onlyCanonical === true) {
+        statusClause = `AND status = 'affirmed'`;
+    }
+    else if (params.includeDenied === true) {
+        statusClause = "";
+    }
+    else {
+        statusClause = `AND status <> 'denied'`;
+    }
+    const sql = `
+    SELECT row_to_json(result) FROM (
+      SELECT
+        id, type, title, content, tags, repo_path,
+        status, confidence, symbol, external_id,
+        corrects_id, corrected_by_id,
+        created_at
+      FROM kodingo_memory
+      WHERE symbol = ${sqlLiteral(params.symbol)}
+      ${statusClause}
+      ${scopeClause}
+      ORDER BY
+        (status = 'affirmed') DESC,
+        confidence DESC,
+        created_at DESC
+      LIMIT ${safeLimit}
+    ) AS result;
+  `;
+    const rows = await runPsqlRows(sql);
+    return rows.map((row) => mapRow(row));
+}
+function mapRow(row) {
+    const status = (row.status ?? "proposed");
+    const confidence = clamp01(typeof row.confidence === "number" ? row.confidence : 0.3);
+    return {
+        id: row.id,
+        type: row.type,
+        title: row.title ?? null,
+        content: row.content,
+        tags: row.tags ?? null,
+        repoPath: row.repo_path ?? null,
+        status,
+        confidence,
+        symbol: row.symbol ?? null,
+        externalId: row.external_id ?? null,
+        correctsId: row.corrects_id ?? null,
+        correctedById: row.corrected_by_id ?? null,
+        createdAt: new Date(row.created_at),
+    };
+}
+function clamp01(n) {
+    if (!Number.isFinite(n))
+        return 0.3;
+    return Math.max(0, Math.min(1, n));
+}
+async function runPsql(sql) {
+    await runPsqlCommand(sql);
+}
+async function runPsqlRows(sql) {
+    const output = await runPsqlCommand(sql);
+    const trimmed = output.trim();
+    if (!trimmed)
+        return [];
+    return trimmed
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line));
+}
+async function runPsqlCommand(sql) {
+    const connectionString = process.env.DATABASE_URL;
+    if (!connectionString)
+        throw new Error("DATABASE_URL is not set");
+    try {
+        const { stdout } = await execFileAsync("psql", [
+            connectionString,
+            "-X",
+            "-q",
+            "-t",
+            "-A",
+            "-v",
+            "ON_ERROR_STOP=1",
+            "-c",
+            sql,
+        ], {
+            env: process.env,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            throw new Error("psql is required but was not found in PATH");
+        }
+        throw error;
+    }
+}
+function sqlLiteral(value) {
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+function sqlNullableLiteral(value) {
+    if (value === undefined || value === null || value === "")
+        return "NULL";
+    return sqlLiteral(value);
+}
+function sqlNullableUuidLiteral(value) {
+    if (!value)
+        return "NULL";
+    return `${sqlLiteral(value)}::uuid`;
+}
+function sqlArrayLiteral(values) {
+    if (!values || values.length === 0)
+        return "NULL";
+    return `ARRAY[${values.map((v) => sqlLiteral(v)).join(", ")}]`;
+}
+function sqlNumberLiteral(value) {
+    if (!Number.isFinite(value))
+        return "0.3";
+    return String(value);
+}

package/dist/adapters/git-adapter/git-listener.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitListenerAdapter = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Git Adapter
+ * - Polls for new commits
+ * - Builds a Decision aligned with kodingo-core types
+ * - Emits through EventPort (no DB knowledge here)
+ *
+ * MVP principle: rely primarily on code changes, not commit messages.
+ * Commit messages are retained as metadata only.
+ */
+class GitListenerAdapter {
+    constructor(repoPath, eventPort, pollInterval = 5000) {
+        this.lastProcessedCommit = null;
+        this.git = (0, simple_git_1.default)(repoPath);
+        this.eventPort = eventPort;
+        this.pollInterval = pollInterval;
+        this.repoPath = repoPath;
+    }
+    async init() {
+        await this.processLatestCommit();
+        this.startWatching();
+    }
+    /**
+     * Run exactly once: process the latest commit only.
+     * (Used by Phase 3.1 "run once" command.)
+     */
+    async runOnceLatest() {
+        await this.processLatestCommit();
+    }
+    startWatching() {
+        setInterval(() => {
+            void this.processNewCommits();
+        }, this.pollInterval);
+    }
+    async processNewCommits() {
+        const log = await this.git.log({ maxCount: 50 });
+        const commits = (log.all ?? []);
+        const newCommits = this.takeCommitsSinceLast(commits, this.lastProcessedCommit);
+        // Process older -> newer (deterministic evolution)
+        for (const commit of newCommits.reverse()) {
+            await this.processCommit(commit);
+            this.lastProcessedCommit = commit.hash;
+        }
+    }
+    /**
+     * From HEAD backward, collect commits until we reach lastHash.
+     * If lastHash is null, return everything passed in.
+     */
+    takeCommitsSinceLast(commits, lastHash) {
+        if (!lastHash)
+            return [...commits];
+        const out = [];
+        for (const c of commits) {
+            if (c.hash === lastHash)
+                break;
+            out.push(c);
+        }
+        return out;
+    }
+    async processCommit(commit) {
+        const projectId = await this.getProjectId();
+        const diffFiles = await this.getCommitDiff(commit.hash);
+        // Extract JS/TS symbols (best effort) — enrich signal metadata
+        const touchedSymbols = this.extractTouchedSymbols(diffFiles);
+        // Diff-first rationale: do not trust commit message as "why"
+        const decision = {
+            id: commit.hash,
+            projectId,
+            rationale: "Inferred from code changes", // MVP: change-based inference
+            changeSummary: this.buildChangeSummary(commit, diffFiles, touchedSymbols),
+            confidence: 0.3, // proposed baseline (matches domain contract spirit)
+            proposedAt: new Date(commit.date),
+        };
+        // Core-aligned context: requires priorMemory + source
+        // MVP: empty prior memory (DB integration can enrich later)
+        const priorMemory = {
+            projectId,
+            decisions: [],
+            updatedAt: new Date(0),
+        };
+        // kodingo-core currently restricts source to "human" | "system".
+        // Git ingestion is an automated system signal, so use "system".
+        const context = {
+            priorMemory,
+            source: "system",
+        };
+        await this.eventPort.pushDecision(decision, context);
+    }
+    /**
+     * Stable summary string that keeps useful Git metadata.
+     * Commit message stored as metadata only (low-trust).
+     */
+    buildChangeSummary(commit, diffFiles, symbols) {
+        const files = diffFiles.map((f) => ({
+            file: f.file,
+            insertions: f.insertions,
+            deletions: f.deletions,
+            binary: f.binary,
+        }));
+        const summaryObj = {
+            source: "git",
+            commitHash: commit.hash,
+            commitMessage: commit.message, // metadata only
+            author: commit.author_name,
+            filesChanged: files,
+            symbolsTouched: symbols,
+        };
+        return JSON.stringify(summaryObj);
+    }
+    /**
+     * Diff summary for a single commit.
+     */
+    async getCommitDiff(commitHash) {
+        const diffSummary = await this.git.diffSummary([`${commitHash}^!`]);
+        return (diffSummary.files ?? []).map((f) => ({
+            file: f.file,
+            insertions: typeof f.insertions === "number" ? f.insertions : 0,
+            deletions: typeof f.deletions === "number" ? f.deletions : 0,
+            changes: typeof f.changes === "number" ? f.changes : 0,
+            binary: !!f.binary,
+        }));
+    }
+    async getProjectId() {
+        const remotes = await this.git.getRemotes(true);
+        const fetchUrl = remotes?.[0]?.refs?.fetch;
+        return fetchUrl || "local-project";
+    }
+    async processLatestCommit() {
+        const log = await this.git.log({ maxCount: 1 });
+        const commits = (log.all ?? []);
+        const latestCommit = commits[0];
+        if (!latestCommit)
+            return;
+        await this.processCommit(latestCommit);
+        this.lastProcessedCommit = latestCommit.hash;
+    }
+    /**
+     * Extract touched function/class names for JS/TS files (best effort).
+     * NOTE: Parses working tree file, not historical snapshot (acceptable for MVP).
+     */
+    extractTouchedSymbols(diffFiles) {
+        const symbols = [];
+        for (const file of diffFiles) {
+            if (file.binary)
+                continue;
+            const isTsOrJs = file.file.endsWith(".ts") || file.file.endsWith(".js");
+            if (!isTsOrJs)
+                continue;
+            const absFilePath = path_1.default.join(this.repoPath, file.file);
+            if (!fs_1.default.existsSync(absFilePath))
+                continue;
+            const content = fs_1.default.readFileSync(absFilePath, "utf-8");
+            try {
+                const ast = (0, parser_1.parse)(content, {
+                    sourceType: "module",
+                    plugins: ["typescript", "classProperties"],
+                });
+                (0, traverse_1.default)(ast, {
+                    FunctionDeclaration(p) {
+                        const name = p?.node?.id?.name;
+                        if (name)
+                            symbols.push(`function:${name}`);
+                    },
+                    ClassDeclaration(p) {
+                        const name = p?.node?.id?.name;
+                        if (name)
+                            symbols.push(`class:${name}`);
+                    },
+                });
+            }
+            catch {
+                // Ignore parse errors for MVP
+            }
+        }
+        return Array.from(new Set(symbols));
+    }
+}
+exports.GitListenerAdapter = GitListenerAdapter;