@renseiai/agentfactory-code-intelligence 0.8.4

package/dist/src/memory/simhash.js

@@ -0,0 +1,67 @@
+/**
+ * SimHash implementation for near-duplicate detection.
+ * Produces a 64-bit fingerprint where similar content produces similar hashes.
+ */
+/** Simple string hash for tokens (FNV-1a-like, 64-bit safe). */
+function tokenHash(token) {
+    let hash = 0xcbf29ce484222325n;
+    for (let i = 0; i < token.length; i++) {
+        hash ^= BigInt(token.charCodeAt(i));
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return hash;
+}
+export class SimHash {
+    bits;
+    constructor(bits = 64) {
+        this.bits = bits;
+    }
+    /** Compute a SimHash fingerprint for the given text. */
+    compute(text) {
+        const tokens = this.tokenize(text);
+        if (tokens.length === 0)
+            return 0n;
+        // Weight vector: one entry per bit
+        const weights = new Float64Array(this.bits);
+        for (const token of tokens) {
+            const hash = tokenHash(token);
+            for (let i = 0; i < this.bits; i++) {
+                if ((hash >> BigInt(i)) & 1n) {
+                    weights[i] += 1;
+                }
+                else {
+                    weights[i] -= 1;
+                }
+            }
+        }
+        // Convert weight vector to fingerprint
+        let fingerprint = 0n;
+        for (let i = 0; i < this.bits; i++) {
+            if (weights[i] > 0) {
+                fingerprint |= 1n << BigInt(i);
+            }
+        }
+        return fingerprint;
+    }
+    /** Compute Hamming distance between two fingerprints. */
+    hammingDistance(a, b) {
+        let xor = a ^ b;
+        let count = 0;
+        while (xor > 0n) {
+            count += Number(xor & 1n);
+            xor >>= 1n;
+        }
+        return count;
+    }
+    /** Check if two fingerprints are near-duplicates within threshold. */
+    isNearDuplicate(a, b, threshold = 3) {
+        return this.hammingDistance(a, b) <= threshold;
+    }
+    tokenize(text) {
+        // Split on whitespace and punctuation, lowercase, filter short tokens
+        return text
+            .toLowerCase()
+            .split(/[\s\p{P}]+/u)
+            .filter(t => t.length >= 2);
+    }
+}

package/dist/src/memory/xxhash.d.ts

@@ -0,0 +1,3 @@
+/** Compute a 64-bit xxHash hex string from content. */
+export declare function xxhash64(content: string): Promise<string>;
+//# sourceMappingURL=xxhash.d.ts.map

package/dist/src/memory/xxhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xxhash.d.ts","sourceRoot":"","sources":["../../../src/memory/xxhash.ts"],"names":[],"mappings":"AAWA,uDAAuD;AACvD,wBAAsB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG/D"}

package/dist/src/memory/xxhash.js

@@ -0,0 +1,13 @@
+import xxhashWasm from 'xxhash-wasm';
+let hasherPromise;
+function getHasher() {
+    if (!hasherPromise) {
+        hasherPromise = xxhashWasm();
+    }
+    return hasherPromise;
+}
+/** Compute a 64-bit xxHash hex string from content. */
+export async function xxhash64(content) {
+    const hasher = await getHasher();
+    return hasher.h64ToString(content);
+}

package/dist/src/parser/__tests__/multi-language.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=multi-language.test.d.ts.map

package/dist/src/parser/__tests__/multi-language.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-language.test.d.ts","sourceRoot":"","sources":["../../../../src/parser/__tests__/multi-language.test.ts"],"names":[],"mappings":""}

package/dist/src/parser/__tests__/multi-language.test.js

@@ -0,0 +1,350 @@
+import { describe, it, expect } from 'vitest';
+import { PythonExtractor } from '../python-extractor.js';
+import { GoExtractor } from '../go-extractor.js';
+import { RustExtractor } from '../rust-extractor.js';
+import { SymbolExtractor } from '../symbol-extractor.js';
+// ── Python ────────────────────────────────────────────────────────────
+const samplePython = `
+import os
+from typing import List, Optional
+from dataclasses import dataclass
+
+@dataclass
+class User:
+    name: str
+    email: str
+
+    def full_name(self) -> str:
+        return self.name
+
+class _InternalHelper:
+    pass
+
+def process_data(items: List[str]) -> List[str]:
+    return [item.strip() for item in items]
+
+async def fetch_users(url: str) -> List[User]:
+    pass
+
+_private_func = lambda x: x
+
+MAX_RETRIES = 3
+`;
+describe('PythonExtractor', () => {
+    const extractor = new PythonExtractor();
+    it('extracts imports', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        expect(result.imports).toContain('os');
+        expect(result.imports).toContain('typing');
+    });
+    it('extracts classes', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const user = result.symbols.find(s => s.name === 'User' && s.kind === 'class');
+        expect(user).toBeDefined();
+        expect(user.exported).toBe(true);
+    });
+    it('marks internal classes as not exported', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const internal = result.symbols.find(s => s.name === '_InternalHelper');
+        expect(internal).toBeDefined();
+        expect(internal.exported).toBe(false);
+    });
+    it('extracts functions', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const fn = result.symbols.find(s => s.name === 'process_data' && s.kind === 'function');
+        expect(fn).toBeDefined();
+        expect(fn.exported).toBe(true);
+    });
+    it('extracts async functions', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const fn = result.symbols.find(s => s.name === 'fetch_users' && s.kind === 'function');
+        expect(fn).toBeDefined();
+    });
+    it('extracts methods', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const method = result.symbols.find(s => s.name === 'full_name' && s.kind === 'method');
+        expect(method).toBeDefined();
+    });
+    it('extracts decorators', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        const dec = result.symbols.find(s => s.name === 'dataclass' && s.kind === 'decorator');
+        expect(dec).toBeDefined();
+    });
+    it('sets language to python', () => {
+        const result = extractor.extract(samplePython, 'main.py');
+        expect(result.language).toBe('python');
+        for (const s of result.symbols) {
+            expect(s.language).toBe('python');
+        }
+    });
+});
+// ── Go ────────────────────────────────────────────────────────────────
+const sampleGo = `
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Server represents an HTTP server
+type Server struct {
+	Port int
+	Host string
+}
+
+// Handler is the request handler interface
+type Handler interface {
+	ServeHTTP(w http.ResponseWriter, r *http.Request)
+}
+
+type myInternal struct{}
+
+// NewServer creates a new Server instance
+func NewServer(port int) *Server {
+	return &Server{Port: port}
+}
+
+// Start starts the server
+func (s *Server) Start() error {
+	return http.ListenAndServe(fmt.Sprintf("%s:%d", s.Host, s.Port), nil)
+}
+
+func (s *Server) internal() {}
+
+var DefaultPort = 8080
+const Version = "1.0"
+`;
+describe('GoExtractor', () => {
+    const extractor = new GoExtractor();
+    it('extracts imports', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        expect(result.imports).toContain('fmt');
+        expect(result.imports).toContain('net/http');
+    });
+    it('extracts structs', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const srv = result.symbols.find(s => s.name === 'Server' && s.kind === 'struct');
+        expect(srv).toBeDefined();
+        expect(srv.exported).toBe(true);
+    });
+    it('extracts interfaces', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const handler = result.symbols.find(s => s.name === 'Handler' && s.kind === 'interface');
+        expect(handler).toBeDefined();
+        expect(handler.exported).toBe(true);
+    });
+    it('marks unexported types', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const internal = result.symbols.find(s => s.name === 'myInternal');
+        expect(internal).toBeDefined();
+        expect(internal.exported).toBe(false);
+    });
+    it('extracts functions', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const fn = result.symbols.find(s => s.name === 'NewServer' && s.kind === 'function');
+        expect(fn).toBeDefined();
+        expect(fn.exported).toBe(true);
+        expect(fn.documentation).toContain('creates a new Server instance');
+    });
+    it('extracts methods with receivers', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const method = result.symbols.find(s => s.name === 'Start' && s.kind === 'method');
+        expect(method).toBeDefined();
+        expect(method.parentName).toBe('Server');
+        expect(method.exported).toBe(true);
+    });
+    it('marks unexported methods', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const method = result.symbols.find(s => s.name === 'internal' && s.kind === 'method');
+        expect(method).toBeDefined();
+        expect(method.exported).toBe(false);
+    });
+    it('extracts variables and constants', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        const v = result.symbols.find(s => s.name === 'DefaultPort');
+        expect(v).toBeDefined();
+        const c = result.symbols.find(s => s.name === 'Version');
+        expect(c).toBeDefined();
+    });
+    it('sets language to go', () => {
+        const result = extractor.extract(sampleGo, 'main.go');
+        expect(result.language).toBe('go');
+    });
+});
+// ── Rust ──────────────────────────────────────────────────────────────
+const sampleRust = `
+use std::io::{self, Read};
+use serde::{Serialize, Deserialize};
+
+/// A configuration struct
+pub struct Config {
+    pub name: String,
+    pub version: u32,
+}
+
+struct InternalState {
+    data: Vec<u8>,
+}
+
+/// The main trait for services
+pub trait Service {
+    fn handle(&self, request: Request) -> Response;
+}
+
+impl Service for Config {
+    fn handle(&self, request: Request) -> Response {
+        unimplemented!()
+    }
+}
+
+impl Config {
+    pub fn new(name: String) -> Self {
+        Config { name, version: 1 }
+    }
+}
+
+/// Process incoming data
+pub async fn process(data: &[u8]) -> io::Result<Vec<u8>> {
+    Ok(data.to_vec())
+}
+
+fn internal_helper() -> bool {
+    true
+}
+
+pub enum Status {
+    Active,
+    Inactive,
+}
+
+macro_rules! log_error {
+    ($msg:expr) => {
+        eprintln!("ERROR: {}", $msg);
+    };
+}
+
+pub const MAX_SIZE: usize = 1024;
+pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+pub mod utils;
+`;
+describe('RustExtractor', () => {
+    const extractor = new RustExtractor();
+    it('extracts use statements', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        expect(result.imports).toContain('std::io::{self, Read}');
+        expect(result.imports).toContain('serde::{Serialize, Deserialize}');
+    });
+    it('extracts pub structs', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const cfg = result.symbols.find(s => s.name === 'Config' && s.kind === 'struct');
+        expect(cfg).toBeDefined();
+        expect(cfg.exported).toBe(true);
+        expect(cfg.documentation).toContain('configuration struct');
+    });
+    it('marks private structs', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const internal = result.symbols.find(s => s.name === 'InternalState');
+        expect(internal).toBeDefined();
+        expect(internal.exported).toBe(false);
+    });
+    it('extracts traits', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const trait_ = result.symbols.find(s => s.name === 'Service' && s.kind === 'trait');
+        expect(trait_).toBeDefined();
+        expect(trait_.exported).toBe(true);
+    });
+    it('extracts impl blocks', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const impls = result.symbols.filter(s => s.kind === 'impl');
+        expect(impls.length).toBeGreaterThanOrEqual(2);
+        const traitImpl = impls.find(s => s.name.includes('Service for Config'));
+        expect(traitImpl).toBeDefined();
+    });
+    it('extracts functions', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const fn_ = result.symbols.find(s => s.name === 'process' && s.kind === 'function');
+        expect(fn_).toBeDefined();
+        expect(fn_.exported).toBe(true);
+        expect(fn_.documentation).toContain('Process incoming data');
+    });
+    it('marks private functions', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const fn_ = result.symbols.find(s => s.name === 'internal_helper');
+        expect(fn_).toBeDefined();
+        expect(fn_.exported).toBe(false);
+    });
+    it('extracts enums', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const en = result.symbols.find(s => s.name === 'Status' && s.kind === 'enum');
+        expect(en).toBeDefined();
+        expect(en.exported).toBe(true);
+    });
+    it('extracts macros', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        const macro_ = result.symbols.find(s => s.name === 'log_error' && s.kind === 'macro');
+        expect(macro_).toBeDefined();
+    });
+    it('extracts const/type/mod', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        expect(result.symbols.find(s => s.name === 'MAX_SIZE' && s.kind === 'variable')).toBeDefined();
+        expect(result.symbols.find(s => s.name === 'Result' && s.kind === 'type')).toBeDefined();
+        expect(result.symbols.find(s => s.name === 'utils' && s.kind === 'module')).toBeDefined();
+    });
+    it('sets language to rust', () => {
+        const result = extractor.extract(sampleRust, 'lib.rs');
+        expect(result.language).toBe('rust');
+    });
+});
+// ── Multi-language registration ───────────────────────────────────────
+describe('SymbolExtractor multi-language', () => {
+    it('registers additional extractors', () => {
+        const extractor = new SymbolExtractor();
+        extractor.registerExtractor(new PythonExtractor());
+        extractor.registerExtractor(new GoExtractor());
+        extractor.registerExtractor(new RustExtractor());
+        expect(extractor.supportsLanguage('python')).toBe(true);
+        expect(extractor.supportsLanguage('go')).toBe(true);
+        expect(extractor.supportsLanguage('rust')).toBe(true);
+    });
+    it('extracts Python from source', () => {
+        const extractor = new SymbolExtractor();
+        extractor.registerExtractor(new PythonExtractor());
+        const result = extractor.extractFromSource('def hello(): pass', 'test.py');
+        expect(result.symbols.length).toBeGreaterThan(0);
+        expect(result.language).toBe('python');
+    });
+    it('extracts Go from source', () => {
+        const extractor = new SymbolExtractor();
+        extractor.registerExtractor(new GoExtractor());
+        const result = extractor.extractFromSource('func main() {}', 'main.go');
+        expect(result.symbols.length).toBeGreaterThan(0);
+        expect(result.language).toBe('go');
+    });
+    it('extracts Rust from source', () => {
+        const extractor = new SymbolExtractor();
+        extractor.registerExtractor(new RustExtractor());
+        const result = extractor.extractFromSource('pub fn main() {}', 'main.rs');
+        expect(result.symbols.length).toBeGreaterThan(0);
+        expect(result.language).toBe('rust');
+    });
+    it('all languages map to unified SymbolKind types', () => {
+        const validKinds = new Set([
+            'function', 'class', 'interface', 'type', 'variable', 'method',
+            'property', 'import', 'export', 'enum', 'struct', 'trait',
+            'impl', 'macro', 'decorator', 'module',
+        ]);
+        const extractor = new SymbolExtractor();
+        extractor.registerExtractor(new PythonExtractor());
+        extractor.registerExtractor(new GoExtractor());
+        extractor.registerExtractor(new RustExtractor());
+        const py = extractor.extractFromSource(samplePython, 'test.py');
+        const go = extractor.extractFromSource(sampleGo, 'test.go');
+        const rs = extractor.extractFromSource(sampleRust, 'test.rs');
+        for (const ast of [py, go, rs]) {
+            for (const symbol of ast.symbols) {
+                expect(validKinds.has(symbol.kind)).toBe(true);
+            }
+        }
+    });
+});

package/dist/src/parser/__tests__/symbol-extractor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=symbol-extractor.test.d.ts.map

package/dist/src/parser/__tests__/symbol-extractor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-extractor.test.d.ts","sourceRoot":"","sources":["../../../../src/parser/__tests__/symbol-extractor.test.ts"],"names":[],"mappings":""}

package/dist/src/parser/__tests__/symbol-extractor.test.js

@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import { SymbolExtractor } from '../symbol-extractor.js';
+import { TypeScriptExtractor } from '../typescript-extractor.js';
+const sampleTS = `
+import { z } from 'zod'
+import type { Foo } from './foo'
+
+/** Configuration interface */
+export interface Config {
+  name: string
+  version: number
+}
+
+export type Result<T> = { data: T; error?: string }
+
+export const DEFAULT_TIMEOUT = 5000
+
+/** Main handler function */
+export async function handleRequest(req: Request): Promise<Response> {
+  return new Response('ok')
+}
+
+export const processData = (input: string) => {
+  return input.trim()
+}
+
+export class UserService {
+  private db: Database
+
+  constructor(db: Database) {
+    this.db = db
+  }
+
+  async getUser(id: string): Promise<User> {
+    return this.db.find(id)
+  }
+
+  async deleteUser(id: string): Promise<void> {
+    await this.db.delete(id)
+  }
+}
+
+export enum Status {
+  Active = 'active',
+  Inactive = 'inactive',
+}
+
+@deprecated
+class OldService {}
+`;
+const sampleJS = `
+const express = require('express')
+const { Router } = require('express')
+
+function createServer(port) {
+  const app = express()
+  return app.listen(port)
+}
+
+class APIClient {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl
+  }
+
+  async fetch(path) {
+    return fetch(this.baseUrl + path)
+  }
+}
+
+const helper = (x) => x * 2
+
+module.exports = { createServer, APIClient }
+`;
+describe('TypeScriptExtractor', () => {
+    const extractor = new TypeScriptExtractor();
+    it('extracts imports', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        expect(result.imports).toContain('zod');
+        expect(result.imports).toContain('./foo');
+    });
+    it('extracts interface', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const iface = result.symbols.find(s => s.name === 'Config' && s.kind === 'interface');
+        expect(iface).toBeDefined();
+        expect(iface.exported).toBe(true);
+    });
+    it('extracts type alias', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const type = result.symbols.find(s => s.name === 'Result' && s.kind === 'type');
+        expect(type).toBeDefined();
+        expect(type.exported).toBe(true);
+    });
+    it('extracts exported variable', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const v = result.symbols.find(s => s.name === 'DEFAULT_TIMEOUT' && s.kind === 'variable');
+        expect(v).toBeDefined();
+        expect(v.exported).toBe(true);
+    });
+    it('extracts async function with JSDoc', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const fn = result.symbols.find(s => s.name === 'handleRequest' && s.kind === 'function');
+        expect(fn).toBeDefined();
+        expect(fn.exported).toBe(true);
+        expect(fn.documentation).toContain('Main handler function');
+    });
+    it('extracts arrow function', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const fn = result.symbols.find(s => s.name === 'processData' && s.kind === 'function');
+        expect(fn).toBeDefined();
+        expect(fn.exported).toBe(true);
+    });
+    it('extracts class with methods', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const cls = result.symbols.find(s => s.name === 'UserService' && s.kind === 'class');
+        expect(cls).toBeDefined();
+        expect(cls.exported).toBe(true);
+        const methods = result.symbols.filter(s => s.parentName === 'UserService' && s.kind === 'method');
+        const methodNames = methods.map(m => m.name);
+        expect(methodNames).toContain('getUser');
+        expect(methodNames).toContain('deleteUser');
+    });
+    it('extracts enum', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const en = result.symbols.find(s => s.name === 'Status' && s.kind === 'enum');
+        expect(en).toBeDefined();
+    });
+    it('extracts decorators', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        const dec = result.symbols.find(s => s.name === 'deprecated' && s.kind === 'decorator');
+        expect(dec).toBeDefined();
+    });
+    it('tracks exports', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        expect(result.exports).toContain('Config');
+        expect(result.exports).toContain('handleRequest');
+        expect(result.exports).toContain('UserService');
+    });
+    it('sets correct language for .ts files', () => {
+        const result = extractor.extract(sampleTS, 'sample.ts');
+        expect(result.language).toBe('typescript');
+    });
+    it('sets correct language for .js files', () => {
+        const result = extractor.extract(sampleJS, 'sample.js');
+        expect(result.language).toBe('javascript');
+    });
+    it('extracts JavaScript functions and classes', () => {
+        const result = extractor.extract(sampleJS, 'sample.js');
+        const fn = result.symbols.find(s => s.name === 'createServer' && s.kind === 'function');
+        expect(fn).toBeDefined();
+        const cls = result.symbols.find(s => s.name === 'APIClient' && s.kind === 'class');
+        expect(cls).toBeDefined();
+    });
+    it('extracts JS arrow functions', () => {
+        const result = extractor.extract(sampleJS, 'sample.js');
+        const fn = result.symbols.find(s => s.name === 'helper' && s.kind === 'function');
+        expect(fn).toBeDefined();
+    });
+});
+describe('SymbolExtractor', () => {
+    const extractor = new SymbolExtractor();
+    it('detects typescript language', () => {
+        expect(extractor.detectLanguage('src/main.ts')).toBe('typescript');
+        expect(extractor.detectLanguage('src/app.tsx')).toBe('typescript');
+    });
+    it('detects javascript language', () => {
+        expect(extractor.detectLanguage('lib/utils.js')).toBe('javascript');
+        expect(extractor.detectLanguage('lib/utils.mjs')).toBe('javascript');
+    });
+    it('detects unknown language', () => {
+        expect(extractor.detectLanguage('main.py')).toBe('python');
+        expect(extractor.detectLanguage('readme.md')).toBe('unknown');
+    });
+    it('supports typescript and javascript', () => {
+        expect(extractor.supportsLanguage('typescript')).toBe(true);
+        expect(extractor.supportsLanguage('javascript')).toBe(true);
+        expect(extractor.supportsLanguage('python')).toBe(false);
+    });
+    it('extracts from source', () => {
+        const result = extractor.extractFromSource(sampleTS, 'test.ts');
+        expect(result.symbols.length).toBeGreaterThan(0);
+        expect(result.language).toBe('typescript');
+    });
+    it('returns empty for unsupported language', () => {
+        const result = extractor.extractFromSource('def hello(): pass', 'test.py');
+        expect(result.symbols).toHaveLength(0);
+        expect(result.language).toBe('python');
+    });
+});

package/dist/src/parser/go-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { FileAST } from '../types.js';
+import type { LanguageExtractor } from './symbol-extractor.js';
+/** Regex-based Go symbol extractor. */
+export declare class GoExtractor implements LanguageExtractor {
+    languages: string[];
+    extract(source: string, filePath: string): FileAST;
+}
+//# sourceMappingURL=go-extractor.d.ts.map

package/dist/src/parser/go-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-extractor.d.ts","sourceRoot":"","sources":["../../../src/parser/go-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAc,MAAM,aAAa,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D,uCAAuC;AACvC,qBAAa,WAAY,YAAW,iBAAiB;IACnD,SAAS,WAAS;IAElB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;CAgInD"}