@zipbul/gildash 0.0.1

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

@@ -0,0 +1,16 @@
+import type { Program, Comment, OxcError } from 'oxc-parser';
+export interface SourcePosition {
+    line: number;
+    column: number;
+}
+export interface SourceSpan {
+    start: SourcePosition;
+    end: SourcePosition;
+}
+export interface ParsedFile {
+    filePath: string;
+    program: Program;
+    errors: readonly OxcError[];
+    comments: readonly Comment[];
+    sourceText: string;
+}

package/dist/src/search/dependency-graph.d.ts

@@ -0,0 +1,71 @@
+import type { RelationRecord } from '../store/repositories/relation.repository';
+export interface IDependencyGraphRepo {
+    getByType(project: string, type: string): RelationRecord[];
+}
+/**
+ * Directed import graph for dependency analysis.
+ *
+ * Build the graph once with {@link DependencyGraph.build}, then query
+ * dependencies, dependents, cycles, and change-impact.
+ *
+ * @example
+ * ```ts
+ * const graph = new DependencyGraph({ relationRepo, project: 'my-app' });
+ * graph.build();
+ * graph.getDependencies('/src/a.ts');  // files that a.ts imports
+ * graph.getDependents('/src/a.ts');    // files that import a.ts
+ * graph.hasCycle();                     // true if a circular import exists
+ * ```
+ */
+export declare class DependencyGraph {
+    private readonly options;
+    private adjacencyList;
+    private reverseAdjacencyList;
+    constructor(options: {
+        relationRepo: IDependencyGraphRepo;
+        project: string;
+    });
+    /**
+     * Populate the graph by reading all `imports` relations from the store.
+     *
+     * Must be called before any query method.
+     */
+    build(): void;
+    /**
+     * Return the files that `filePath` directly imports.
+     *
+     * @param filePath - Absolute file path.
+     */
+    getDependencies(filePath: string): string[];
+    /**
+     * Return the files that directly import `filePath`.
+     *
+     * @param filePath - Absolute file path.
+     */
+    getDependents(filePath: string): string[];
+    /**
+     * Return all files that transitively depend on `filePath`
+     * (breadth-first reverse walk).
+     *
+     * @param filePath - Absolute file path.
+     */
+    getTransitiveDependents(filePath: string): string[];
+    /**
+     * Detect whether the import graph contains at least one cycle.
+     *
+     * Uses iterative DFS with a path-tracking set.
+     *
+     * @returns `true` if a circular dependency exists.
+     */
+    hasCycle(): boolean;
+    /**
+     * Compute all files transitively affected by a set of changed files.
+     *
+     * Combines {@link getTransitiveDependents} for every changed file
+     * and de-duplicates the result.
+     *
+     * @param changedFiles - Absolute paths of files that changed.
+     * @returns Paths of all transitively-dependent files.
+     */
+    getAffectedByChange(changedFiles: string[]): string[];
+}

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

@@ -0,0 +1,6 @@
+export { symbolSearch } from './symbol-search';
+export type { SymbolSearchQuery, SymbolSearchResult, ISymbolRepo } from './symbol-search';
+export { relationSearch } from './relation-search';
+export type { RelationSearchQuery, IRelationRepo } from './relation-search';
+export { DependencyGraph } from './dependency-graph';
+export type { IDependencyGraphRepo } from './dependency-graph';

package/dist/src/search/relation-search.d.ts

@@ -0,0 +1,45 @@
+import type { CodeRelation } from '../extractor/types';
+import type { RelationRecord } from '../store/repositories/relation.repository';
+/**
+ * Filters for {@link relationSearch}.
+ *
+ * All fields are optional. Omitted fields impose no constraint.
+ */
+export interface RelationSearchQuery {
+    /** Source file path. */
+    srcFilePath?: string;
+    /** Source symbol name. */
+    srcSymbolName?: string;
+    /** Destination file path. */
+    dstFilePath?: string;
+    /** Destination symbol name. */
+    dstSymbolName?: string;
+    /** Relationship type: `'imports'`, `'calls'`, `'extends'`, or `'implements'`. */
+    type?: CodeRelation['type'];
+    /** Limit results to this project. */
+    project?: string;
+    /** Maximum number of results. Defaults to `500`. */
+    limit?: number;
+}
+export interface IRelationRepo {
+    searchRelations(opts: {
+        srcFilePath?: string;
+        srcSymbolName?: string;
+        dstFilePath?: string;
+        dstSymbolName?: string;
+        type?: string;
+        project?: string;
+        limit: number;
+    }): RelationRecord[];
+}
+/**
+ * Search the relation index using the given query filters.
+ *
+ * @param options - Relation repository, default project, and search query.
+ * @returns An array of {@link CodeRelation} entries matching the query.
+ */
+export declare function relationSearch(options: {
+    relationRepo: IRelationRepo;
+    project?: string;
+    query: RelationSearchQuery;
+}): CodeRelation[];

package/dist/src/search/symbol-search.d.ts

@@ -0,0 +1,76 @@
+import type { SymbolKind } from '../extractor/types';
+import type { SymbolRecord } from '../store/repositories/symbol.repository';
+/**
+ * Filters for {@link symbolSearch}.
+ *
+ * All fields are optional. Omitted fields impose no constraint.
+ */
+export interface SymbolSearchQuery {
+    /** Full-text search on symbol names (prefix matching). */
+    text?: string;
+    /** Restrict to a specific {@link SymbolKind}. */
+    kind?: SymbolKind;
+    /** Restrict to symbols declared in this file path. */
+    filePath?: string;
+    /** `true` for exported symbols only, `false` for non-exported only. */
+    isExported?: boolean;
+    /** Limit results to this project. Defaults to the primary project. */
+    project?: string;
+    /** Maximum number of results. Defaults to `100`. */
+    limit?: number;
+}
+/**
+ * A single result returned by {@link symbolSearch}.
+ */
+export interface SymbolSearchResult {
+    /** Database row id. */
+    id: number;
+    /** Absolute file path containing the symbol. */
+    filePath: string;
+    /** Kind of the symbol (function, class, variable, etc.). */
+    kind: SymbolKind;
+    /** Symbol name. */
+    name: string;
+    /** Source location span (start/end line and column). */
+    span: {
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    /** Whether the symbol is exported from its module. */
+    isExported: boolean;
+    /** Human-readable signature text, if available. */
+    signature: string | null;
+    /** Content-hash fingerprint for change detection. */
+    fingerprint: string | null;
+    /** Arbitrary detail fields stored as JSON. */
+    detail: Record<string, unknown>;
+}
+export interface ISymbolRepo {
+    searchByQuery(opts: {
+        ftsQuery?: string;
+        kind?: string;
+        filePath?: string;
+        isExported?: boolean;
+        project?: string;
+        limit: number;
+    }): (SymbolRecord & {
+        id: number;
+    })[];
+}
+/**
+ * Search the symbol index using the given query filters.
+ *
+ * @param options - Symbol repository, default project, and search query.
+ * @returns An array of {@link SymbolSearchResult} entries matching the query.
+ */
+export declare function symbolSearch(options: {
+    symbolRepo: ISymbolRepo;
+    project?: string;
+    query: SymbolSearchQuery;
+}): SymbolSearchResult[];

package/dist/src/store/connection.d.ts

@@ -0,0 +1,30 @@
+import { type BunSQLiteDatabase } from 'drizzle-orm/bun-sqlite';
+import * as schema from './schema';
+export interface DbConnectionOptions {
+    projectRoot: string;
+}
+export declare class DbConnection {
+    private client;
+    private drizzle;
+    private readonly dbPath;
+    private txDepth;
+    constructor(opts: DbConnectionOptions);
+    get drizzleDb(): BunSQLiteDatabase<typeof schema>;
+    open(): void;
+    close(): void;
+    transaction<T>(fn: (tx: DbConnection) => T): T;
+    immediateTransaction<T>(fn: () => T): T;
+    query(sql: string): unknown;
+    getTableNames(): string[];
+    selectOwner(): {
+        pid: number;
+        heartbeat_at: string;
+    } | undefined;
+    insertOwner(pid: number): void;
+    replaceOwner(pid: number): void;
+    touchOwner(pid: number): void;
+    deleteOwner(pid: number): void;
+    private requireClient;
+    private closeClient;
+    private isCorruptionError;
+}

package/dist/src/store/index.d.ts

@@ -0,0 +1,10 @@
+export { DbConnection } from './connection';
+export type { DbConnectionOptions } from './connection';
+export { FileRepository } from './repositories/file.repository';
+export type { FileRecord } from './repositories/file.repository';
+export { SymbolRepository } from './repositories/symbol.repository';
+export type { SymbolRecord, SearchOptions, SymbolStats } from './repositories/symbol.repository';
+export { RelationRepository } from './repositories/relation.repository';
+export type { RelationRecord } from './repositories/relation.repository';
+export * as schema from './schema';
+export { FTS_SETUP_SQL } from './schema';

package/dist/src/store/repositories/file.repository.d.ts

@@ -0,0 +1,18 @@
+import type { DbConnection } from '../connection';
+export interface FileRecord {
+    project: string;
+    filePath: string;
+    mtimeMs: number;
+    size: number;
+    contentHash: string;
+    updatedAt: string;
+}
+export declare class FileRepository {
+    private readonly db;
+    constructor(db: DbConnection);
+    getFile(project: string, filePath: string): FileRecord | null;
+    upsertFile(record: FileRecord): void;
+    getAllFiles(project: string): FileRecord[];
+    getFilesMap(project: string): Map<string, FileRecord>;
+    deleteFile(project: string, filePath: string): void;
+}

package/dist/src/store/repositories/fts-utils.d.ts

@@ -0,0 +1 @@
+export declare function toFtsPrefixQuery(text: string): string;

package/dist/src/store/repositories/relation.repository.d.ts

@@ -0,0 +1,29 @@
+import type { DbConnection } from '../connection';
+export interface RelationRecord {
+    project: string;
+    type: string;
+    srcFilePath: string;
+    srcSymbolName: string | null;
+    dstFilePath: string;
+    dstSymbolName: string | null;
+    metaJson: string | null;
+}
+export declare class RelationRepository {
+    private readonly db;
+    constructor(db: DbConnection);
+    replaceFileRelations(project: string, srcFilePath: string, rels: ReadonlyArray<Partial<RelationRecord>>): void;
+    getOutgoing(project: string, srcFilePath: string, srcSymbolName?: string): RelationRecord[];
+    getIncoming(project: string, dstFilePath: string): RelationRecord[];
+    getByType(project: string, type: string): RelationRecord[];
+    deleteFileRelations(project: string, srcFilePath: string): void;
+    searchRelations(opts: {
+        srcFilePath?: string;
+        srcSymbolName?: string;
+        dstFilePath?: string;
+        dstSymbolName?: string;
+        type?: string;
+        project?: string;
+        limit: number;
+    }): RelationRecord[];
+    retargetRelations(project: string, oldFile: string, oldSymbol: string | null, newFile: string, newSymbol: string | null): void;
+}

package/dist/src/store/repositories/symbol.repository.d.ts

@@ -0,0 +1,46 @@
+import type { DbConnection } from '../connection';
+export interface SymbolRecord {
+    project: string;
+    filePath: string;
+    kind: string;
+    name: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+    isExported: number;
+    signature: string | null;
+    fingerprint: string | null;
+    detailJson: string | null;
+    contentHash: string;
+    indexedAt: string;
+}
+export interface SearchOptions {
+    kind?: string;
+    limit?: number;
+}
+export interface SymbolStats {
+    symbolCount: number;
+    fileCount: number;
+}
+export declare class SymbolRepository {
+    private readonly db;
+    constructor(db: DbConnection);
+    replaceFileSymbols(project: string, filePath: string, contentHash: string, syms: ReadonlyArray<Partial<SymbolRecord>>): void;
+    getFileSymbols(project: string, filePath: string): SymbolRecord[];
+    searchByName(project: string, query: string, opts?: SearchOptions): SymbolRecord[];
+    searchByKind(project: string, kind: string): SymbolRecord[];
+    getStats(project: string): SymbolStats;
+    getByFingerprint(project: string, fingerprint: string): SymbolRecord[];
+    deleteFileSymbols(project: string, filePath: string): void;
+    searchByQuery(opts: {
+        ftsQuery?: string;
+        kind?: string;
+        filePath?: string;
+        isExported?: boolean;
+        project?: string;
+        limit: number;
+    }): (SymbolRecord & {
+        id: number;
+    })[];
+}