@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-ROMM6KMC.js

@@ -0,0 +1,433 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/brain/brain.sql.ts
+var brain_sql_exports = {};
+__export(brain_sql_exports, {
+  BrainAnalysisFindingTable: () => BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable: () => BrainAnalysisOccurrenceTable,
+  BrainAnalysisRunTable: () => BrainAnalysisRunTable,
+  BrainFileTable: () => BrainFileTable,
+  BrainImportTable: () => BrainImportTable,
+  BrainIndexStatusTable: () => BrainIndexStatusTable,
+  BrainProjectHealthTable: () => BrainProjectHealthTable,
+  BrainQueryCacheTable: () => BrainQueryCacheTable,
+  BrainRelationshipTable: () => BrainRelationshipTable,
+  BrainSemanticEmbeddingTable: () => BrainSemanticEmbeddingTable,
+  BrainSymbolTable: () => BrainSymbolTable,
+  BrainTaintFlowTable: () => BrainTaintFlowTable
+});
+import { sqliteTable as sqliteTable2, text as text2, integer as integer2, real, blob, index } from "drizzle-orm/sqlite-core";
+
+// src/project/project.sql.ts
+var project_sql_exports = {};
+__export(project_sql_exports, {
+  ProjectTable: () => ProjectTable
+});
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var ProjectTable = sqliteTable("project", {
+  id: text("id").primaryKey(),
+  workspace_id: text("workspace_id").notNull(),
+  name: text("name"),
+  time_created: integer("time_created").notNull(),
+  time_updated: integer("time_updated").notNull()
+});
+
+// src/brain/brain.sql.ts
+var Timestamps = {
+  time_created: integer2("time_created").notNull(),
+  time_updated: integer2("time_updated").notNull()
+};
+var BrainFileTable = sqliteTable2(
+  "brain_file",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    path: text2().notNull(),
+    relative_path: text2().notNull(),
+    file_hash: text2().notNull(),
+    size_bytes: integer2(),
+    line_count: integer2(),
+    language: text2(),
+    last_modified: real(),
+    indexed_at: text2(),
+    layer: text2(),
+    // e.g., "ui", "business", "data", "infrastructure"
+    is_test_file: integer2({ mode: "boolean" }),
+    is_config_file: integer2({ mode: "boolean" }),
+    is_documentation: integer2({ mode: "boolean" }),
+    framework_type: text2(),
+    // e.g., "react", "flutter", "express", "django"
+    has_syntax_errors: integer2({ mode: "boolean" }).notNull().default(false),
+    error_report: text2({ mode: "json" }),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_file_project_idx").on(table.project_id),
+    index("brain_file_path_idx").on(table.path),
+    index("brain_file_language_idx").on(table.language),
+    index("brain_file_hash_idx").on(table.file_hash),
+    index("brain_file_syntax_errors_idx").on(table.has_syntax_errors),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_file_proj_path_idx").on(table.project_id, table.path),
+    index("brain_file_proj_hash_idx").on(table.project_id, table.file_hash)
+  ]
+);
+var BrainSymbolTable = sqliteTable2(
+  "brain_symbol",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    file_id: text2().notNull().references(() => BrainFileTable.id, { onDelete: "cascade" }),
+    name: text2().notNull(),
+    qualified_name: text2(),
+    // Full namespace/module path
+    symbol_type: text2().notNull(),
+    // "function", "class", "variable", "interface", "enum", "type", etc.
+    line_start: integer2(),
+    line_end: integer2(),
+    byte_start: integer2(),
+    byte_end: integer2(),
+    return_type: text2(),
+    parameters: text2({ mode: "json" }),
+    docstring: text2(),
+    visibility: text2(),
+    // "public", "private", "protected", "internal"
+    is_async: integer2({ mode: "boolean" }),
+    is_static: integer2({ mode: "boolean" }),
+    is_abstract: integer2({ mode: "boolean" }),
+    is_override: integer2({ mode: "boolean" }),
+    is_getter: integer2({ mode: "boolean" }),
+    is_setter: integer2({ mode: "boolean" }),
+    complexity: integer2(),
+    owner_symbol_id: text2(),
+    // Parent class/namespace
+    scope_kind: text2(),
+    // "global", "class", "function", "module"
+    is_declaration: integer2({ mode: "boolean" }),
+    // #612: analyzer-published declaration (c prototype, cpp/rust/zig signature form); NULL/0 = definition
+    annotations: text2({ mode: "json" }),
+    // Language-specific annotations/decorators
+    generic_parameters: text2({ mode: "json" }),
+    qualified_calls: text2({ mode: "json" }),
+    // ProxiCall-style: JSON array of qualified call strings extracted as-is
+    gravity_score: real().default(0),
+    layer: text2().default("core"),
+    api_contract_path: text2(),
+    // Deterministic mapping: Exact Route URL or Fetch URL for 100% accurate cross-language links
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_symbol_project_idx").on(table.project_id),
+    index("brain_symbol_file_idx").on(table.file_id),
+    index("brain_symbol_name_idx").on(table.name),
+    index("brain_symbol_type_idx").on(table.symbol_type),
+    index("brain_symbol_qualified_idx").on(table.qualified_name),
+    index("brain_symbol_owner_idx").on(table.owner_symbol_id),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_sym_proj_file_idx").on(table.project_id, table.file_id),
+    index("brain_sym_proj_name_idx").on(table.project_id, table.name),
+    index("brain_sym_proj_type_idx").on(table.project_id, table.symbol_type),
+    // Tool query: find symbol by project + name + type (callers/callees trace)
+    index("brain_sym_proj_name_type_idx").on(table.project_id, table.name, table.symbol_type)
+  ]
+);
+var BrainRelationshipTable = sqliteTable2(
+  "brain_relationship",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    source_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    target_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "set null" }),
+    source_external: text2(),
+    // For unresolved / external sources (when source is a string but symbol not declared)
+    target_external: text2(),
+    // For external dependencies
+    relationship_type: text2().notNull(),
+    // "calls", "extends", "implements", "uses", "imports", "exports", etc.
+    confidence: real().notNull(),
+    // 0.0 to 1.0 - AI confidence in relationship
+    context: text2(),
+    // Additional context about the relationship
+    line_number: integer2(),
+    // Where relationship occurs
+    is_cross_language: integer2({ mode: "boolean" }),
+    // True for relationships across languages
+    bridge_mechanism: text2(),
+    // How cross-language bridge works (API, FFI, etc.)
+    is_cross_file: integer2({ mode: "boolean" }).notNull().default(false),
+    // Fast UI stat index
+    metadata: text2({ mode: "json" }),
+    // Flexible metadata storage
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_rel_project_idx").on(table.project_id),
+    index("brain_rel_source_idx").on(table.source_symbol_id),
+    index("brain_rel_target_idx").on(table.target_symbol_id),
+    // Enrichment in-degree: GROUP BY target_symbol_id WHERE project_id
+    index("brain_rel_proj_target_idx").on(table.project_id, table.target_symbol_id),
+    index("brain_rel_type_idx").on(table.relationship_type),
+    index("brain_rel_confidence_idx").on(table.confidence),
+    index("brain_rel_cross_lang_idx").on(table.is_cross_language),
+    index("brain_rel_cross_file_idx").on(table.is_cross_file),
+    // COMPOUND INDEXES for ultra-fast lookups
+    index("brain_rel_proj_source_idx").on(table.project_id, table.source_symbol_id),
+    index("brain_rel_proj_target_idx").on(table.project_id, table.target_symbol_id),
+    index("brain_rel_proj_type_idx").on(table.project_id, table.relationship_type),
+    // Tool query: find callers/callees by target symbol + relationship type
+    index("brain_rel_target_type_idx").on(table.target_symbol_id, table.relationship_type),
+    // M29.R3: hover's cross-language probes (is_cross_language = 1 AND
+    // target/source_symbol_id = ?) need the composite form — see schema-ddl.ts.
+    index("brain_rel_target_cross_idx").on(table.target_symbol_id, table.is_cross_language),
+    index("brain_rel_source_cross_idx").on(table.source_symbol_id, table.is_cross_language)
+  ]
+);
+var BrainImportTable = sqliteTable2(
+  "brain_import",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    file_id: text2().notNull().references(() => BrainFileTable.id, { onDelete: "cascade" }),
+    imported_name: text2().notNull(),
+    imported_as: text2(),
+    // Alias name
+    import_path: text2().notNull(),
+    import_type: text2().notNull(),
+    // "default", "named", "namespace", "side_effect"
+    is_external: integer2({ mode: "boolean" }),
+    // External package vs internal
+    package_name: text2(),
+    // For external imports
+    line_number: integer2(),
+    is_dynamic: integer2({ mode: "boolean" }),
+    // Dynamic imports
+    resolved_symbol_id: text2(),
+    // Link to actual symbol if internal
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_import_project_idx").on(table.project_id),
+    index("brain_import_file_idx").on(table.file_id),
+    index("brain_import_path_idx").on(table.import_path),
+    index("brain_import_name_idx").on(table.imported_name),
+    index("brain_import_external_idx").on(table.is_external)
+  ]
+);
+var BrainTaintFlowTable = sqliteTable2(
+  "brain_taint_flow",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    source_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    sink_symbol_id: text2().references(() => BrainSymbolTable.id, { onDelete: "cascade" }),
+    source_type: text2().notNull(),
+    // "user_input", "database_read", "network_receive"
+    sink_type: text2().notNull(),
+    // "database_write", "log_output", "shell_execution", "http_response"
+    vulnerability_type: text2().notNull(),
+    // "sql_injection", "xss", "pii_leak", "command_injection"
+    severity: text2().notNull(),
+    // "critical", "high", "medium", "low"
+    is_mitigated: integer2({ mode: "boolean" }).notNull().default(false),
+    flow_path: text2({ mode: "json" }),
+    // Array of intermediate symbol IDs
+    cross_language_boundaries: integer2().notNull().default(0),
+    mitigation_steps: text2({ mode: "json" }),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_taint_project_idx").on(table.project_id),
+    index("brain_taint_source_idx").on(table.source_symbol_id),
+    index("brain_taint_sink_idx").on(table.sink_symbol_id),
+    index("brain_taint_vuln_idx").on(table.vulnerability_type),
+    index("brain_taint_severity_idx").on(table.severity)
+  ]
+);
+var BrainAnalysisRunTable = sqliteTable2(
+  "brain_analysis_run",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    kind: text2().notNull(),
+    status: text2().notNull(),
+    engine_version: text2().notNull(),
+    input_hash: text2().notNull(),
+    started_at: integer2().notNull(),
+    completed_at: integer2(),
+    finding_count: integer2().notNull().default(0),
+    error: text2(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_run_project_idx").on(table.project_id),
+    index("brain_analysis_run_kind_idx").on(table.kind),
+    index("brain_analysis_run_started_idx").on(table.started_at)
+  ]
+);
+var BrainAnalysisFindingTable = sqliteTable2(
+  "brain_analysis_finding",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    kind: text2().notNull(),
+    fingerprint: text2().notNull(),
+    rule: text2().notNull(),
+    title: text2().notNull(),
+    severity: text2().notNull(),
+    state: text2().notNull(),
+    confidence: real(),
+    evidence: text2({ mode: "json" }),
+    first_seen_at: integer2().notNull(),
+    last_seen_at: integer2().notNull(),
+    resolved_at: integer2(),
+    suppressed_at: integer2(),
+    mitigated_at: integer2(),
+    occurrence_count: integer2().notNull().default(0),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_finding_project_idx").on(table.project_id),
+    index("brain_analysis_finding_fingerprint_idx").on(table.project_id, table.kind, table.fingerprint),
+    index("brain_analysis_finding_state_idx").on(table.project_id, table.state)
+  ]
+);
+var BrainAnalysisOccurrenceTable = sqliteTable2(
+  "brain_analysis_occurrence",
+  {
+    id: text2().primaryKey(),
+    finding_id: text2().notNull().references(() => BrainAnalysisFindingTable.id, { onDelete: "cascade" }),
+    run_id: text2().notNull().references(() => BrainAnalysisRunTable.id, { onDelete: "cascade" }),
+    state: text2().notNull(),
+    location: text2(),
+    evidence: text2({ mode: "json" }),
+    observed_at: integer2().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_analysis_occurrence_finding_idx").on(table.finding_id),
+    index("brain_analysis_occurrence_run_idx").on(table.run_id)
+  ]
+);
+var BrainQueryCacheTable = sqliteTable2(
+  "brain_query_cache",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    query_type: text2().notNull(),
+    // "call_graph", "impact_analysis", "feature_map", etc.
+    query_hash: text2().notNull(),
+    query_params: text2({ mode: "json" }),
+    result_data: text2({ mode: "json" }),
+    confidence: real().notNull(),
+    computation_time_ms: integer2(),
+    cache_expires_at: integer2(),
+    hit_count: integer2().notNull().default(0),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_cache_project_idx").on(table.project_id),
+    index("brain_cache_query_type_idx").on(table.query_type),
+    index("brain_cache_hash_idx").on(table.query_hash),
+    index("brain_cache_expires_idx").on(table.cache_expires_at)
+  ]
+);
+var BrainProjectHealthTable = sqliteTable2("brain_project_health", {
+  project_id: text2().$type().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  complexity_score: integer2().notNull().default(0),
+  // 0-100
+  maintainability_score: integer2().notNull().default(0),
+  // 0-100
+  technical_debt_score: integer2().notNull().default(0),
+  // 0-100
+  code_quality_score: integer2().notNull().default(0),
+  // 0-100
+  language_distribution: text2({ mode: "json" }),
+  // LanguageMetric[]
+  service_metrics: text2({ mode: "json" }),
+  // ServiceMetric[]
+  dependency_metrics: text2({ mode: "json" }),
+  // DependencyMetric
+  circular_dependencies: text2({ mode: "json" }),
+  // string[][]
+  contract_drift: text2({ mode: "json" }),
+  // string[]
+  performance_bottlenecks: text2({ mode: "json" }),
+  // string[]
+  ...Timestamps
+});
+var BrainIndexStatusTable = sqliteTable2("brain_index_status", {
+  project_id: text2().$type().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  status: text2(),
+  // M21.I2: persisted complete/partial status (previously dropped)
+  last_full_index: integer2(),
+  // Timestamp
+  last_incremental_index: integer2(),
+  total_files: integer2().notNull().default(0),
+  indexed_files: integer2().notNull().default(0),
+  total_symbols: integer2().notNull().default(0),
+  total_relationships: integer2().notNull().default(0),
+  indexing_version: text2().notNull(),
+  // Schema version for migrations
+  languages_detected: text2({ mode: "json" }),
+  // Array of languages found
+  frameworks_detected: text2({ mode: "json" }),
+  // Array of frameworks detected
+  indexing_errors: text2({ mode: "json" }),
+  // Array of error messages
+  performance_stats: text2({ mode: "json" }),
+  // Indexing performance metrics
+  ...Timestamps
+});
+var BrainSemanticEmbeddingTable = sqliteTable2(
+  "brain_semantic_embedding",
+  {
+    id: text2().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    entity_id: text2().notNull(),
+    // Can be symbol_id, file_id, or pattern_id
+    entity_type: text2().notNull(),
+    // "symbol", "file", "pattern", "comment", "documentation"
+    embedding_model: text2().notNull(),
+    // "openai-ada-002", "sentence-transformers", etc.
+    embedding_vector: text2().notNull(),
+    // "" for dense rows (blob is authoritative); JSON for sparse/legacy rows
+    // Dense vectors are stored ONCE here as little-endian float32 (2026-11-01 contract);
+    // NULL on legacy rows (readers then scan embedding_vector). See vector-binary.ts.
+    embedding_blob: blob("embedding_blob", { mode: "buffer" }),
+    vector_dimension: integer2().notNull(),
+    content_hash: text2().notNull(),
+    // Hash of content that generated embedding
+    semantic_context: text2({ mode: "json" }),
+    // Additional context for better search
+    similarity_threshold: real().default(0.7),
+    // Minimum similarity for matches
+    last_updated: integer2().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    index("brain_embed_project_idx").on(table.project_id),
+    index("brain_embed_entity_idx").on(table.entity_id),
+    index("brain_embed_type_idx").on(table.entity_type),
+    index("brain_embed_model_idx").on(table.embedding_model),
+    index("brain_embed_hash_idx").on(table.content_hash)
+  ]
+);
+
+export {
+  project_sql_exports,
+  BrainFileTable,
+  BrainSymbolTable,
+  BrainRelationshipTable,
+  BrainImportTable,
+  BrainTaintFlowTable,
+  BrainAnalysisRunTable,
+  BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable,
+  BrainQueryCacheTable,
+  BrainProjectHealthTable,
+  BrainIndexStatusTable,
+  BrainSemanticEmbeddingTable,
+  brain_sql_exports
+};