@plebeiantech/lat.md 0.12.3-fork.16 → 0.12.3-fork.17

package/dist/src/search/types.d.ts

@@ -0,0 +1,31 @@
+export type SourceSpan = {
+    start: number;
+    end: number;
+    startLine: number;
+    endLine: number;
+};
+export type SearchEvidence = {
+    chunkId: string;
+    text: string;
+    spans: SourceSpan[];
+    channel: 'lexical' | 'semantic';
+};
+export type SearchDiagnostics = {
+    lexicalCapped: boolean;
+    semanticCapped: boolean;
+    lexicalCandidates: number;
+    semanticCandidates: number;
+};
+export type SearchResult = {
+    id: string;
+    file: string;
+    heading: string;
+    content: string;
+    rankScore: number;
+    semanticSimilarity?: number;
+    semanticRank?: number;
+    lexicalScore?: number;
+    lexicalRank?: number;
+    evidence: SearchEvidence[];
+    diagnostics: SearchDiagnostics;
+};

package/dist/src/search/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/source-formats.d.ts

@@ -1,5 +1,5 @@
 /** Source file extensions supported by Lat's parser and code-reference scan. */
-export declare const SOURCE_FILE_EXTENSIONS: readonly [".c", ".dart", ".go", ".h", ".java", ".js", ".jsx", ".py", ".rake", ".rb", ".rs", ".ts", ".tsx"];
+export declare const SOURCE_FILE_EXTENSIONS: readonly [".c", ".dart", ".erb", ".go", ".h", ".java", ".js", ".jsx", ".php", ".py", ".rake", ".rb", ".rs", ".ts", ".tsx"];
 /** A source extension supported everywhere Lat accepts source files. */
 export type SourceFileExtension = (typeof SOURCE_FILE_EXTENSIONS)[number];
 export declare function isSourceFileExtension(extension: string): extension is SourceFileExtension;

package/dist/src/source-formats.js

@@ -3,11 +3,13 @@ import { extname } from 'node:path';
 export const SOURCE_FILE_EXTENSIONS = [
     '.c',
     '.dart',
+    '.erb',
     '.go',
     '.h',
     '.java',
     '.js',
     '.jsx',
+    '.php',
     '.py',
     '.rake',
     '.rb',

package/dist/src/source-parser.js

@@ -28,11 +28,13 @@ async function ensureParser() {
 const grammarMap = {
     '.c': 'tree-sitter-c.wasm',
     '.dart': 'tree-sitter-dart.wasm',
+    '.erb': 'tree-sitter-ruby.wasm',
     '.go': 'tree-sitter-go.wasm',
     '.h': 'tree-sitter-c.wasm',
     '.java': 'tree-sitter-java.wasm',
     '.js': 'tree-sitter-javascript.wasm',
     '.jsx': 'tree-sitter-javascript.wasm',
+    '.php': 'tree-sitter-php.wasm',
     '.py': 'tree-sitter-python.wasm',
     '.rake': 'tree-sitter-ruby.wasm',
     '.rb': 'tree-sitter-ruby.wasm',
@@ -752,6 +754,125 @@ function extractJavaSymbols(tree) {
     collectJavaScope(sourceLines, tree.rootNode, undefined, symbols);
     return symbols;
 }
+function phpSignature(sourceLines, node) {
+    const declaration = node.namedChildren.find((child) => child.type !== 'attribute_list');
+    return sourceLines[(declaration ?? node).startPosition.row]?.trim() ?? '';
+}
+function phpName(node) {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode?.type === 'by_ref') {
+        return (nameNode.namedChildren
+            .find((child) => child.type === 'variable_name')
+            ?.text.replace(/^\$/, '') ?? null);
+    }
+    const name = extractName(node) ??
+        node.namedChildren.find((child) => child.type === 'name')?.text ??
+        null;
+    return name?.replace(/^\$/, '') ?? null;
+}
+function pushPhpSymbol(sourceLines, symbols, node, name, kind, parent) {
+    symbols.push({
+        name,
+        kind,
+        ...(parent ? { parent } : {}),
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        signature: phpSignature(sourceLines, node),
+    });
+}
+function extractPhpVariables(sourceLines, symbols, node, parent) {
+    const kind = node.type === 'const_declaration' ? 'const' : 'variable';
+    for (const child of node.namedChildren) {
+        if (child.type !== 'const_element' && child.type !== 'property_element') {
+            continue;
+        }
+        const name = phpName(child);
+        if (name)
+            pushPhpSymbol(sourceLines, symbols, node, name, kind, parent);
+    }
+}
+const phpTypeKinds = {
+    class_declaration: 'class',
+    interface_declaration: 'interface',
+    trait_declaration: 'interface',
+    enum_declaration: 'class',
+};
+// Recurse through declaration containers, not arbitrary expressions: anonymous
+// classes and closures must not leak their members into the enclosing scope.
+const phpScopeContainers = new Set([
+    'namespace_definition',
+    'compound_statement',
+    'declaration_list',
+    'enum_declaration_list',
+    'if_statement',
+    'else_if_clause',
+    'else_clause',
+    'switch_statement',
+    'switch_block',
+    'case_statement',
+    'default_statement',
+    'while_statement',
+    'do_statement',
+    'for_statement',
+    'foreach_statement',
+    'try_statement',
+    'catch_clause',
+    'finally_clause',
+    'declare_statement',
+]);
+function collectPhpScope(sourceLines, scope, symbols, parent) {
+    for (const node of scope.namedChildren) {
+        const typeKind = phpTypeKinds[node.type];
+        if (typeKind) {
+            const name = phpName(node);
+            if (!name)
+                continue;
+            pushPhpSymbol(sourceLines, symbols, node, name, typeKind);
+            const body = node.childForFieldName('body');
+            if (body)
+                collectPhpScope(sourceLines, body, symbols, name);
+            continue;
+        }
+        if (node.type === 'function_definition' && !parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'function');
+        }
+        else if (node.type === 'method_declaration' && parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'method', parent);
+            if (name?.toLowerCase() === '__construct') {
+                const parameters = node.childForFieldName('parameters');
+                for (const parameter of parameters?.namedChildren ?? []) {
+                    if (parameter.type !== 'property_promotion_parameter')
+                        continue;
+                    const propertyName = phpName(parameter);
+                    if (!propertyName)
+                        continue;
+                    pushPhpSymbol(sourceLines, symbols, parameter, propertyName, 'variable', parent);
+                }
+            }
+        }
+        else if (node.type === 'const_declaration' ||
+            node.type === 'property_declaration') {
+            extractPhpVariables(sourceLines, symbols, node, parent);
+        }
+        else if (node.type === 'enum_case' && parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'const', parent);
+        }
+        else if (phpScopeContainers.has(node.type)) {
+            collectPhpScope(sourceLines, node, symbols, parent);
+        }
+    }
+}
+function extractPhpSymbols(tree) {
+    const symbols = [];
+    collectPhpScope(tree.rootNode.text.split('\n'), tree.rootNode, symbols);
+    return symbols;
+}
 function extractRustSymbols(tree) {
     const symbols = [];
     const root = tree.rootNode;
@@ -1294,11 +1415,13 @@ function firstLine(text) {
 const symbolExtractors = {
     '.c': extractCSymbols,
     '.dart': extractDartSymbols,
+    '.erb': extractRubySymbols,
     '.go': extractGoSymbols,
     '.h': extractCSymbols,
     '.java': extractJavaSymbols,
     '.js': extractTsSymbols,
     '.jsx': extractTsSymbols,
+    '.php': extractPhpSymbols,
     '.py': extractPySymbols,
     '.rake': extractRubySymbols,
     '.rb': extractRubySymbols,
@@ -1306,6 +1429,78 @@ const symbolExtractors = {
     '.ts': extractTsSymbols,
     '.tsx': extractTsSymbols,
 };
+function preprocessErb(content) {
+    let result = '';
+    let inRuby = false;
+    let inComment = false;
+    let i = 0;
+    while (i < content.length) {
+        if (!inRuby && !inComment) {
+            if (content.startsWith('<%%', i)) {
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('<%#', i)) {
+                inComment = true;
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('<%', i)) {
+                inRuby = true;
+                let tagLen = 2;
+                while (i + tagLen < content.length &&
+                    ['=', '-', '~'].includes(content[i + tagLen])) {
+                    tagLen++;
+                }
+                result += ' '.repeat(tagLen);
+                i += tagLen;
+            }
+            else {
+                const ch = content[i];
+                result += ch === '\n' ? '\n' : ' ';
+                i++;
+            }
+        }
+        else if (inComment) {
+            if (content.startsWith('%>', i)) {
+                inComment = false;
+                result += '  ';
+                i += 2;
+            }
+            else if (content.startsWith('-%>', i) || content.startsWith('~%>', i)) {
+                inComment = false;
+                result += '   ';
+                i += 3;
+            }
+            else {
+                const ch = content[i];
+                result += ch === '\n' ? '\n' : ' ';
+                i++;
+            }
+        }
+        else {
+            if (content.startsWith('%%>', i)) {
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('%>', i)) {
+                inRuby = false;
+                result += '  ';
+                i += 2;
+            }
+            else if (content.startsWith('-%>', i) || content.startsWith('~%>', i)) {
+                inRuby = false;
+                result += '   ';
+                i += 3;
+            }
+            else {
+                result += content[i];
+                i++;
+            }
+        }
+    }
+    return result;
+}
 export async function parseSourceSymbols(filePath, content) {
     const ext = sourceFileExtension(filePath);
     if (!ext)
@@ -1313,7 +1508,8 @@ export async function parseSourceSymbols(filePath, content) {
     const lang = await getLanguage(ext);
     const p = await ensureParser();
     p.setLanguage(lang);
-    const tree = p.parse(content);
+    const parsedContent = ext === '.erb' && content.includes('<%') ? preprocessErb(content) : content;
+    const tree = p.parse(parsedContent);
     if (!tree)
         return [];
     try {