grepmax 0.23.0 → 0.25.0

package/dist/lib/index/walker.js

@@ -32,16 +32,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -49,6 +39,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
     var i, p;
     return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
@@ -66,103 +57,92 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
     function reject(value) { resume("throw", value); }
     function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWalkState = createWalkState;
+exports.isPathProtectedByWalkState = isPathProtectedByWalkState;
 exports.walk = walk;
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
-const ignore_1 = __importDefault(require("ignore"));
-const ignore_patterns_1 = require("./ignore-patterns");
-function getIgnoreFilter(dir, ignoreFiles) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let filter = null;
-        for (const fileName of ignoreFiles) {
-            const ignorePath = path.join(dir, fileName);
-            try {
-                const content = yield fs.readFile(ignorePath, "utf-8");
-                if (!filter)
-                    filter = (0, ignore_1.default)();
-                filter.add(content);
-            }
-            catch (_err) {
-                // Ignore missing files
-            }
-        }
-        return filter;
-    });
+const path_containment_1 = require("../utils/path-containment");
+const file_policy_1 = require("./file-policy");
+function createWalkState() {
+    return { rootComplete: true, protectedPaths: new Set(), errors: [] };
+}
+function isPathProtectedByWalkState(candidate, state) {
+    if (!state.rootComplete)
+        return true;
+    return Array.from(state.protectedPaths).some((protectedPath) => (0, path_containment_1.isPathWithin)(protectedPath, candidate));
 }
 function walk(rootDir_1) {
     return __asyncGenerator(this, arguments, function* walk_1(rootDir, options = {}) {
-        const ignoreFiles = options.ignoreFiles || [".gitignore", ".gmaxignore"];
-        const rootParams = (0, ignore_1.default)().add(ignore_patterns_1.DEFAULT_IGNORE_PATTERNS);
-        if (options.additionalPatterns) {
-            rootParams.add(options.additionalPatterns);
-        }
-        // Initial scope for root
-        const rootScope = {
-            filter: rootParams,
-            dir: rootDir,
-        };
-        // Stack of scopes.
-        // We check against ALL scopes in the stack.
-        // This implements the "additive" ignore behavior (files ignored by parent are ignored by child).
-        // Note: This does not strictly support "un-ignoring" a parent rule via a child .gitignore
-        // (because we check parent independently), but it is the safest robust implementation for "hiding" nested files.
-        const stack = [rootScope];
-        // We also try to load root .gitignore immediately to add to the stack
-        const rootGitIgnore = yield __await(getIgnoreFilter(rootDir, ignoreFiles));
-        if (rootGitIgnore) {
-            stack.push({ filter: rootGitIgnore, dir: rootDir });
-        }
-        yield __await(yield* __asyncDelegator(__asyncValues(_walk(rootDir, rootDir, stack, ignoreFiles))));
+        var _a, _b;
+        const root = path.resolve(rootDir);
+        const policy = (_a = options.policy) !== null && _a !== void 0 ? _a : new file_policy_1.ProjectFilePolicy(root, {
+            ignoreFiles: options.ignoreFiles,
+            additionalPatterns: options.additionalPatterns,
+        });
+        const state = (_b = options.state) !== null && _b !== void 0 ? _b : createWalkState();
+        yield __await(yield* __asyncDelegator(__asyncValues(walkDirectory(root, root, policy, state, true))));
     });
 }
-function _walk(currentDir, rootDir, stack, ignoreFiles) {
-    return __asyncGenerator(this, arguments, function* _walk_1() {
+function walkDirectory(currentDir, rootDir, policy, state, isRoot) {
+    return __asyncGenerator(this, arguments, function* walkDirectory_1() {
+        const directory = yield __await(policy.classifyDirectory(currentDir));
+        if (directory.status === "error") {
+            state.protectedPaths.add(directory.protectedPath);
+            state.errors.push({
+                path: directory.protectedPath,
+                error: directory.error,
+            });
+            if (isRoot)
+                state.rootComplete = false;
+            return yield __await(void 0);
+        }
+        if (directory.status !== "traverse") {
+            if (isRoot)
+                state.rootComplete = false;
+            return yield __await(void 0);
+        }
         let entries;
         try {
             entries = yield __await(fs.readdir(currentDir, { withFileTypes: true }));
         }
-        catch (_err) {
+        catch (error) {
+            state.protectedPaths.add(currentDir);
+            state.errors.push({ path: currentDir, error });
+            if (isRoot)
+                state.rootComplete = false;
             return yield __await(void 0);
         }
         for (const entry of entries) {
             const absPath = path.join(currentDir, entry.name);
-            const relPathToRoot = path.relative(rootDir, absPath);
-            // 1. Check if ignored by any scope in the stack
-            const isDir = entry.isDirectory();
-            let isIgnored = false;
-            for (const scope of stack) {
-                const relToScope = path.relative(scope.dir, absPath);
-                if (!relToScope)
-                    continue;
-                // Append trailing slash for directories so patterns like "dist/" match
-                const testPath = isDir ? `${relToScope}/` : relToScope;
-                if (scope.filter.ignores(testPath)) {
-                    isIgnored = true;
-                    break;
-                }
-            }
-            if (isIgnored)
-                continue;
             if (entry.isDirectory()) {
-                // 2. Prepare scope for the new directory
-                const childIgnore = yield __await(getIgnoreFilter(absPath, ignoreFiles));
-                if (childIgnore) {
-                    // Push new scope
-                    stack.push({ filter: childIgnore, dir: absPath });
-                    yield __await(yield* __asyncDelegator(__asyncValues(_walk(absPath, rootDir, stack, ignoreFiles))));
-                    stack.pop();
+                yield __await(yield* __asyncDelegator(__asyncValues(walkDirectory(absPath, rootDir, policy, state, false))));
+                continue;
+            }
+            if (!entry.isFile()) {
+                try {
+                    const stat = yield __await(fs.lstat(absPath));
+                    if (stat.isDirectory()) {
+                        yield __await(yield* __asyncDelegator(__asyncValues(walkDirectory(absPath, rootDir, policy, state, false))));
+                        continue;
+                    }
+                    if (!stat.isFile())
+                        continue;
                 }
-                else {
-                    // Just recurse with same stack
-                    yield __await(yield* __asyncDelegator(__asyncValues(_walk(absPath, rootDir, stack, ignoreFiles))));
+                catch (error) {
+                    state.protectedPaths.add(absPath);
+                    state.errors.push({ path: absPath, error });
+                    continue;
                 }
             }
-            else {
-                yield yield __await(relPathToRoot);
+            const file = yield __await(policy.classifyFile(absPath));
+            if (file.status === "indexable") {
+                yield yield __await(path.relative(rootDir, absPath));
+            }
+            else if (file.status === "error") {
+                state.protectedPaths.add(file.protectedPath);
+                state.errors.push({ path: file.protectedPath, error: file.error });
             }
         }
     });

package/dist/lib/index/watcher-batch.js

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBatchCore = processBatchCore;
 exports.flushBatchToDb = flushBatchToDb;
+exports.computePathRetry = computePathRetry;
 exports.computeRetryAction = computeRetryAction;
 const fs = __importStar(require("node:fs"));
 const cache_check_1 = require("../utils/cache-check");
@@ -139,6 +140,14 @@ function flushBatchToDb(result, vectorDb) {
         }
     });
 }
+function computePathRetry(previousFailures, maxFailures, baseDelayMs) {
+    const failures = previousFailures + 1;
+    return {
+        retry: failures < maxFailures,
+        failures,
+        backoffMs: Math.min(baseDelayMs * Math.pow(2, failures), 30000),
+    };
+}
 function computeRetryAction(batch, retryCount, maxRetries, isLockError, consecutiveLockFailures, debounceMs) {
     var _a;
     const requeued = new Map();

package/dist/lib/index/watcher.js

@@ -41,11 +41,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WATCHER_IGNORE_GLOBS = void 0;
 exports.startWatcher = startWatcher;
+const path = __importStar(require("node:path"));
 const watcher = __importStar(require("@parcel/watcher"));
 const batch_processor_1 = require("./batch-processor");
+const file_policy_1 = require("./file-policy");
+const walker_1 = require("./walker");
 // Ignore patterns for @parcel/watcher (micromatch globs + directory names).
 // Directory names are matched at any depth automatically.
 exports.WATCHER_IGNORE_GLOBS = [
@@ -70,15 +80,125 @@ exports.WATCHER_IGNORE_GLOBS = [
     ".m2",
     "vendor",
     "lancedb",
-    ".*", // dotfiles
     "**/*.tmp.*", // editor atomic save artifacts
     "**/*.sb-*", // Xcode swap files
 ];
 function startWatcher(opts) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         const { projectRoot } = opts;
         const wtag = `watch:${projectRoot.split("/").pop()}`;
-        const processor = new batch_processor_1.ProjectBatchProcessor(opts);
+        const filePolicy = new file_policy_1.ProjectFilePolicy(projectRoot);
+        let reconciliation = null;
+        let reconcileRequested = false;
+        let closing = false;
+        let scanHealthy = ((_a = opts.initialScanErrors) !== null && _a !== void 0 ? _a : 0) === 0;
+        let ingestionDegraded = ((_b = opts.initialFailedFiles) !== null && _b !== void 0 ? _b : 0) > 0;
+        let degradedRepairQueued = false;
+        const terminalFailures = new Set();
+        let processor;
+        const reportHealthyIfSettled = () => {
+            var _a;
+            if (scanHealthy &&
+                !ingestionDegraded &&
+                terminalFailures.size === 0 &&
+                processor.progress.pendingFiles === 0) {
+                (_a = opts.onHealthChange) === null || _a === void 0 ? void 0 : _a.call(opts, true, 0);
+            }
+        };
+        const reconcile = () => {
+            if (closing)
+                return;
+            if (reconciliation) {
+                reconcileRequested = true;
+                return;
+            }
+            reconciliation = (() => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                var _d;
+                let incompleteRetries = 0;
+                do {
+                    reconcileRequested = false;
+                    filePolicy.invalidateIgnoreCache();
+                    const rootPrefix = projectRoot.endsWith("/")
+                        ? projectRoot
+                        : `${projectRoot}/`;
+                    const cached = yield opts.metaCache.getKeysWithPrefix(rootPrefix);
+                    const seen = new Set();
+                    const state = (0, walker_1.createWalkState)();
+                    try {
+                        for (var _e = true, _f = (e_1 = void 0, __asyncValues((0, walker_1.walk)(projectRoot, {
+                            policy: filePolicy,
+                            state,
+                        }))), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                            _c = _g.value;
+                            _e = false;
+                            const relative = _c;
+                            if (closing)
+                                return;
+                            const absolute = path.join(projectRoot, relative);
+                            seen.add(absolute);
+                            processor.handleFileEvent("change", absolute);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    for (const cachedPath of cached) {
+                        if (closing)
+                            return;
+                        if (!seen.has(cachedPath) &&
+                            !(0, walker_1.isPathProtectedByWalkState)(cachedPath, state)) {
+                            processor.handleFileEvent("unlink", cachedPath);
+                        }
+                    }
+                    if (!state.rootComplete || state.errors.length > 0) {
+                        scanHealthy = false;
+                        (_d = opts.onHealthChange) === null || _d === void 0 ? void 0 : _d.call(opts, false, state.errors.length);
+                        console.error(`[${wtag}] Reconciliation incomplete at ${state.errors.length} path(s)`);
+                        if (incompleteRetries < 3) {
+                            incompleteRetries++;
+                            reconcileRequested = true;
+                            yield new Promise((resolve) => setTimeout(resolve, 1000 * Math.pow(2, (incompleteRetries - 1))));
+                        }
+                    }
+                    else {
+                        scanHealthy = true;
+                        if (ingestionDegraded && processor.progress.pendingFiles > 0) {
+                            degradedRepairQueued = true;
+                        }
+                        reportHealthyIfSettled();
+                        incompleteRetries = 0;
+                    }
+                } while (reconcileRequested && !closing);
+            }))()
+                .catch((err) => console.error(`[${wtag}] Reconciliation failed:`, err))
+                .finally(() => {
+                reconciliation = null;
+            });
+        };
+        processor = new batch_processor_1.ProjectBatchProcessor(Object.assign(Object.assign({}, opts), { filePolicy, onPolicyChange: reconcile, onReindex: (files, durationMs) => {
+                var _a;
+                (_a = opts.onReindex) === null || _a === void 0 ? void 0 : _a.call(opts, files, durationMs);
+                reportHealthyIfSettled();
+            }, onTerminalFailure: (absPath) => {
+                var _a;
+                terminalFailures.add(absPath);
+                (_a = opts.onHealthChange) === null || _a === void 0 ? void 0 : _a.call(opts, false, terminalFailures.size);
+            }, onPathSuccess: (absPath) => {
+                terminalFailures.delete(absPath);
+                if (degradedRepairQueued &&
+                    terminalFailures.size === 0 &&
+                    processor.progress.pendingFiles === 0) {
+                    ingestionDegraded = false;
+                    degradedRepairQueued = false;
+                }
+                reportHealthyIfSettled();
+            } }));
         const subscription = yield watcher.subscribe(projectRoot, (err, events) => {
             if (err) {
                 console.error(`[${wtag}] Watcher error:`, err);
@@ -88,10 +208,16 @@ function startWatcher(opts) {
                 processor.handleFileEvent(event.type === "delete" ? "unlink" : "change", event.path);
             }
         }, { ignore: exports.WATCHER_IGNORE_GLOBS });
+        reconcile();
         return {
+            get progress() {
+                return processor.progress;
+            },
             close: () => __awaiter(this, void 0, void 0, function* () {
-                yield processor.close();
+                closing = true;
                 yield subscription.unsubscribe();
+                yield reconciliation;
+                yield processor.close();
             }),
         };
     });

package/dist/lib/llm/server.js

@@ -51,6 +51,12 @@ const config_1 = require("../../config");
 const index_config_1 = require("../index/index-config");
 const log_rotate_1 = require("../utils/log-rotate");
 const config_2 = require("./config");
+// ⛔ HARD STOP FOR AI AGENTS: This starts llama-server with a multi-GB local
+// LLM (Qwen3.5-35B GGUF ≈21GB by default). DO NOT start it — via start(),
+// llm-start, reviewCommit, investigate, or a benchmark — without the user's
+// explicit, in-session authorization. Loading models this size has crashed the
+// machine. Stop and ask first. See the "HARD STOP" section at the top of
+// CLAUDE.md.
 const HEALTH_TIMEOUT_MS = 2000;
 const POLL_INTERVAL_MS = 500;
 const STOP_GRACE_MS = 5000;

package/dist/lib/search/searcher.js

@@ -101,14 +101,30 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
     if (typeof roleFilter === "string" && roleFilter) {
         parts.push(`role = '${(0, filter_builder_1.escapeSqlString)(roleFilter)}'`);
     }
-    const projectRoots = filters === null || filters === void 0 ? void 0 : filters.project_roots;
-    if (typeof projectRoots === "string" && projectRoots) {
-        const roots = projectRoots.split(",");
-        const clauses = roots.map((r) => {
-            const prefix = r.endsWith("/") ? r : `${r}/`;
-            return (0, filter_builder_1.pathStartsWith)(prefix);
-        });
-        parts.push(`(${clauses.join(" OR ")})`);
+    const projectRoots = filters === null || filters === void 0 ? void 0 : filters.projectRoots;
+    if (Array.isArray(projectRoots)) {
+        const roots = projectRoots.filter((root) => typeof root === "string" && root.length > 0);
+        if (roots.length === 0) {
+            parts.push("1 = 0");
+        }
+        else {
+            const clauses = roots.map((root) => {
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                return (0, filter_builder_1.pathStartsWith)(prefix);
+            });
+            parts.push(`(${clauses.join(" OR ")})`);
+        }
+    }
+    else {
+        const legacyProjectRoots = filters === null || filters === void 0 ? void 0 : filters.project_roots;
+        if (typeof legacyProjectRoots === "string" && legacyProjectRoots) {
+            const roots = legacyProjectRoots.split(",");
+            const clauses = roots.map((r) => {
+                const prefix = r.endsWith("/") ? r : `${r}/`;
+                return (0, filter_builder_1.pathStartsWith)(prefix);
+            });
+            parts.push(`(${clauses.join(" OR ")})`);
+        }
     }
     const excludeRoots = filters === null || filters === void 0 ? void 0 : filters.exclude_project_roots;
     if (typeof excludeRoots === "string" && excludeRoots) {
@@ -132,8 +148,9 @@ function buildWhereClause(pathPrefix, filters, searchIntent) {
     return parts.length > 0 ? parts.join(" AND ") : undefined;
 }
 class Searcher {
-    constructor(db) {
+    constructor(db, workerPool = (0, pool_1.getWorkerPool)()) {
         this.db = db;
+        this.workerPool = workerPool;
         this.ftsIndexChecked = false;
         this.ftsAvailable = false;
         this.ftsLastCheckedAt = 0;
@@ -389,7 +406,7 @@ class Searcher {
             const searchIntent = intent || (0, intent_1.detectIntent)(query);
             // Bare-identifier queries get symbol-definition promotion (see below).
             const symbolQuery = asSymbolQuery(query);
-            const pool = (0, pool_1.getWorkerPool)();
+            const pool = this.workerPool;
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 const err = new Error("Aborted");
                 err.name = "AbortError";
@@ -409,13 +426,7 @@ class Searcher {
             const PRE_RERANK_K = Number.isFinite(envPreK) && envPreK > 0
                 ? envPreK
                 : Math.max(finalLimit * 5, 500);
-            let table;
-            try {
-                table = yield this.db.ensureTable();
-            }
-            catch (_r) {
-                return { data: [] };
-            }
+            const table = yield this.db.ensureTable();
             // Ensure FTS index exists (lazy init, retry periodically on failure)
             const now = Date.now();
             if (!this.ftsIndexChecked ||
@@ -496,7 +507,7 @@ class Searcher {
                             this.ftsAvailable = true;
                             console.warn("[Searcher] Rebuilt FTS index with position support — retry search");
                         }
-                        catch (_s) { }
+                        catch (_r) { }
                     }
                     else {
                         console.warn(`[Searcher] FTS search failed (will retry later): ${msg}`);
@@ -806,7 +817,7 @@ class Searcher {
                                         defs = arr.filter((v) => typeof v === "string");
                                     }
                                 }
-                                catch (_t) { }
+                                catch (_s) { }
                             }
                             const norm = (0, pagerank_1.pageRankBoostForSymbols)(defs, prScores, prMax);
                             item.score += PR_WEIGHT * norm;

package/dist/lib/skeleton/skeletonizer.js

@@ -69,6 +69,8 @@ const DEFAULT_OPTIONS = {
     includeSummary: true,
     maxCallsInSummary: 4,
 };
+const SQL_TEMPLATE_LANGS = new Set(["typescript", "tsx", "javascript"]);
+const SQL_IDENTIFIER_PATTERN = '(?:"[^"]+"|\\[[^\\]]+\\]|`[^`]+`|[A-Za-z_][\\w$]*)(?:\\s*\\.\\s*(?:"[^"]+"|\\[[^\\]]+\\]|`[^`]+`|[A-Za-z_][\\w$]*)){0,2}';
 // WASM locator (same as chunker.ts)
 function resolveTreeSitterWasmLocator() {
     try {
@@ -238,10 +240,12 @@ class Skeletonizer {
         }
         // Extract metadata from the body
         const referencedSymbols = this.extractReferencedSymbols(bodyNode);
+        const sqlTemplates = this.extractSqlTemplateSummaries(bodyNode, langId);
         const complexity = this.calculateComplexity(bodyNode);
         const role = this.classifyRole(complexity, referencedSymbols.length);
         const metadata = {
             referencedSymbols,
+            sqlTemplates,
             complexity,
             role,
         };
@@ -450,6 +454,120 @@ class Skeletonizer {
         extract(node);
         return refs;
     }
+    /**
+     * Surface SQL tagged templates hidden inside elided JS/TS function bodies.
+     * This is intentionally a lightweight skeleton hint, not a SQL parser.
+     */
+    extractSqlTemplateSummaries(node, langId) {
+        if (!SQL_TEMPLATE_LANGS.has(langId))
+            return [];
+        const summaries = [];
+        const seen = new Set();
+        const extract = (n) => {
+            const template = (n.namedChildren || []).find((child) => child.type === "template_string");
+            if (template && this.isSqlTaggedTemplate(n, template)) {
+                const summary = this.summarizeSqlTemplate(template);
+                if (summary && !seen.has(summary)) {
+                    seen.add(summary);
+                    summaries.push(summary);
+                }
+                return;
+            }
+            for (const child of n.namedChildren || []) {
+                extract(child);
+            }
+        };
+        extract(node);
+        return summaries;
+    }
+    isSqlTaggedTemplate(node, template) {
+        const tagText = node.text
+            .slice(0, template.startIndex - node.startIndex)
+            .trim();
+        return /(?:^|[.\s])sql(?:$|[.<(])/.test(tagText);
+    }
+    summarizeSqlTemplate(template) {
+        var _a;
+        const sqlText = this.extractTemplateText(template)
+            .replace(/--[^\n]*/g, " ")
+            .replace(/\/\*[\s\S]*?\*\//g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (!sqlText)
+            return null;
+        const op = (_a = sqlText.match(/\b(select|insert|update|delete|merge|create|alter|drop|truncate)\b/i)) === null || _a === void 0 ? void 0 : _a[1];
+        if (!op)
+            return "SQL";
+        const operation = op.toUpperCase();
+        const tables = this.extractSqlTables(sqlText, operation);
+        if (tables.length === 0)
+            return operation;
+        const tableList = tables.slice(0, 2);
+        if (tables.length > tableList.length)
+            tableList.push("...");
+        return `${operation} ${tableList.join(", ")}`;
+    }
+    extractTemplateText(template) {
+        const parts = [];
+        for (const child of template.namedChildren || []) {
+            if (child.type === "string_fragment") {
+                parts.push(child.text);
+            }
+            else if (child.type === "template_substitution") {
+                parts.push(" ? ");
+            }
+        }
+        if (parts.length > 0)
+            return parts.join("");
+        return template.text.slice(1, -1).replace(/\$\{[^}]*\}/g, " ? ");
+    }
+    extractSqlTables(sqlText, operation) {
+        const tables = [];
+        const seen = new Set();
+        const addMatches = (pattern) => {
+            for (const match of sqlText.matchAll(pattern)) {
+                const table = this.normalizeSqlIdentifier(match[1]);
+                if (table && !seen.has(table)) {
+                    seen.add(table);
+                    tables.push(table);
+                }
+            }
+        };
+        switch (operation) {
+            case "SELECT":
+                addMatches(new RegExp(`\\b(?:from|join)\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "INSERT":
+                addMatches(new RegExp(`\\binsert\\s+into\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "UPDATE":
+                addMatches(new RegExp(`\\bupdate\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "DELETE":
+                addMatches(new RegExp(`\\bdelete\\s+from\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "MERGE":
+                addMatches(new RegExp(`\\bmerge\\s+into\\s+(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "CREATE":
+                addMatches(new RegExp(`\\bcreate\\s+(?:or\\s+replace\\s+)?(?:table|view|materialized\\s+view|index)\\s+(?:if\\s+not\\s+exists\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "ALTER":
+            case "DROP":
+                addMatches(new RegExp(`\\b${operation.toLowerCase()}\\s+(?:table|view|materialized\\s+view|index)\\s+(?:if\\s+(?:exists|not\\s+exists)\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+            case "TRUNCATE":
+                addMatches(new RegExp(`\\btruncate\\s+(?:table\\s+)?(${SQL_IDENTIFIER_PATTERN})`, "gi"));
+                break;
+        }
+        return tables;
+    }
+    normalizeSqlIdentifier(identifier) {
+        const normalized = identifier === null || identifier === void 0 ? void 0 : identifier.replace(/\s*\.\s*/g, ".").replace(/["`[\]]/g, "").trim();
+        if (!normalized || normalized === "?")
+            return null;
+        return normalized;
+    }
     /**
      * Calculate cyclomatic complexity of a node.
      */

package/dist/lib/skeleton/summary-formatter.js

@@ -25,7 +25,7 @@ const DEFAULT_OPTIONS = {
  * // Output: "// → findByEmail, compare, sign | C:8 | ORCH"
  */
 function formatSummary(metadata, options = {}) {
-    var _a;
+    var _a, _b;
     const opts = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
     const parts = [];
     // Calls (referenced symbols)
@@ -36,6 +36,13 @@ function formatSummary(metadata, options = {}) {
         }
         parts.push(`→ ${calls.join(", ")}`);
     }
+    if ((_b = metadata.sqlTemplates) === null || _b === void 0 ? void 0 : _b.length) {
+        const templates = metadata.sqlTemplates.slice(0, 3);
+        if (metadata.sqlTemplates.length > templates.length) {
+            templates.push("...");
+        }
+        parts.push(`SQL: ${templates.join("; ")}`);
+    }
     // Complexity (only if > 1, trivial functions don't need it)
     if (opts.showComplexity && metadata.complexity && metadata.complexity > 1) {
         parts.push(`C:${metadata.complexity}`);