@specferret/core 0.1.4 → 0.2.0

package/src/store/sqlite.ts

@@ -1,17 +1,9 @@
-import { Database } from "bun:sqlite";
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { randomUUID } from "node:crypto";
-import { findProjectRoot } from "../utils/paths.js";
-import type {
-  DBStore,
-  FerretNode,
-  FerretContract,
-  FerretDependency,
-  FerretReconciliationLog,
-  FerretPlacementDecision,
-  NodeStatus,
-} from "./types.js";
+import { Database } from 'bun:sqlite';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { findProjectRoot } from '../utils/paths.js';
+import type { DBStore, FerretNode, FerretContract, FerretDependency, FerretReconciliationLog, FerretPlacementDecision, NodeStatus } from './types.js';
 
 export class SqliteStore implements DBStore {
   private db: Database | null = null;
@@ -19,36 +11,27 @@ export class SqliteStore implements DBStore {
 
   constructor(customPath?: string) {
     const root = findProjectRoot();
-    const defaultPath = path.join(root, ".ferret", "graph.db");
-    this.dbPath =
-      customPath === ":memory:"
-        ? ":memory:"
-        : customPath
-          ? path.resolve(root, customPath)
-          : defaultPath;
+    const defaultPath = path.join(root, '.ferret', 'graph.db');
+    this.dbPath = customPath === ':memory:' ? ':memory:' : customPath ? path.resolve(root, customPath) : defaultPath;
   }
 
   async init(): Promise<void> {
     if (this.db) return;
 
-    if (this.dbPath !== ":memory:") {
+    if (this.dbPath !== ':memory:') {
       const ferretDir = path.dirname(this.dbPath);
       if (!fs.existsSync(ferretDir)) {
         fs.mkdirSync(ferretDir, { recursive: true });
       }
-      const gitignorePath = path.join(ferretDir, ".gitignore");
+      const gitignorePath = path.join(ferretDir, '.gitignore');
       try {
-        fs.writeFileSync(
-          gitignorePath,
-          "*\n!.gitignore\n!context.json\n",
-          "utf-8",
-        );
+        fs.writeFileSync(gitignorePath, '*\n!.gitignore\n!context.json\n', 'utf-8');
       } catch {}
     }
 
     this.db = new Database(this.dbPath);
-    this.db.exec("PRAGMA journal_mode = WAL;");
-    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec('PRAGMA journal_mode = WAL;');
+    this.db.exec('PRAGMA foreign_keys = ON;');
 
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS ferret_nodes (
@@ -95,9 +78,15 @@ export class SqliteStore implements DBStore {
     `);
 
     try {
-      this.db.exec(
-        `ALTER TABLE ferret_contracts ADD COLUMN shape_schema TEXT NOT NULL DEFAULT '{}';`,
-      );
+      this.db.exec(`ALTER TABLE ferret_contracts ADD COLUMN shape_schema TEXT NOT NULL DEFAULT '{}';`);
+    } catch {}
+
+    try {
+      this.db.exec(`ALTER TABLE ferret_contracts ADD COLUMN code_source_file TEXT;`);
+    } catch {}
+
+    try {
+      this.db.exec(`ALTER TABLE ferret_contracts ADD COLUMN code_source_symbol TEXT;`);
     } catch {}
   }
 
@@ -109,9 +98,7 @@ export class SqliteStore implements DBStore {
   }
 
   async getNodeByFilePath(filePath: string): Promise<FerretNode | null> {
-    const row = this.db!.prepare(
-      "SELECT * FROM ferret_nodes WHERE file_path = ?",
-    ).get(filePath) as any;
+    const row = this.db!.prepare('SELECT * FROM ferret_nodes WHERE file_path = ?').get(filePath) as any;
     return row ?? null;
   }
 
@@ -130,22 +117,22 @@ export class SqliteStore implements DBStore {
   }
 
   async getAllContractIds(): Promise<string[]> {
-    return (
-      this.db!.prepare("SELECT id FROM ferret_contracts").all() as any[]
-    ).map((r) => r.id);
+    return (this.db!.prepare('SELECT id FROM ferret_contracts').all() as any[]).map((r) => r.id);
   }
 
   async upsertContract(contract: FerretContract): Promise<void> {
     this.db!.prepare(
       `
-      INSERT INTO ferret_contracts (id, node_id, shape_hash, shape_schema, type, status)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO ferret_contracts (id, node_id, shape_hash, shape_schema, type, status, code_source_file, code_source_symbol)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         node_id = excluded.node_id,
         shape_hash = excluded.shape_hash,
         shape_schema = excluded.shape_schema,
         type = excluded.type,
-        status = excluded.status
+        status = excluded.status,
+        code_source_file = excluded.code_source_file,
+        code_source_symbol = excluded.code_source_symbol
     `,
     ).run(
       contract.id,
@@ -154,6 +141,8 @@ export class SqliteStore implements DBStore {
       contract.shape_schema,
       contract.type,
       contract.status,
+      contract.code_source_file ?? null,
+      contract.code_source_symbol ?? null,
     );
   }
 
@@ -164,21 +153,12 @@ export class SqliteStore implements DBStore {
       VALUES (?, ?, ?)
       ON CONFLICT(id) DO NOTHING
     `,
-    ).run(
-      dependency.id,
-      dependency.source_node_id,
-      dependency.target_contract_id,
-    );
+    ).run(dependency.id, dependency.source_node_id, dependency.target_contract_id);
   }
 
-  async replaceDependenciesForSourceNode(
-    sourceNodeId: string,
-    targetContractIds: string[],
-  ): Promise<void> {
+  async replaceDependenciesForSourceNode(sourceNodeId: string, targetContractIds: string[]): Promise<void> {
     const uniqueTargets = [...new Set(targetContractIds)].sort();
-    const deleteStatement = this.db!.prepare(
-      "DELETE FROM ferret_dependencies WHERE source_node_id = ?",
-    );
+    const deleteStatement = this.db!.prepare('DELETE FROM ferret_dependencies WHERE source_node_id = ?');
     const insertStatement = this.db!.prepare(
       `
       INSERT INTO ferret_dependencies (id, source_node_id, target_contract_id)
@@ -197,40 +177,28 @@ export class SqliteStore implements DBStore {
   }
 
   async getNodes(): Promise<FerretNode[]> {
-    return this.db!.prepare(
-      "SELECT * FROM ferret_nodes",
-    ).all() as unknown as FerretNode[];
+    return this.db!.prepare('SELECT * FROM ferret_nodes').all() as unknown as FerretNode[];
   }
 
   async getNodesByStatus(status: NodeStatus): Promise<FerretNode[]> {
-    return this.db!.prepare("SELECT * FROM ferret_nodes WHERE status = ?").all(
-      status,
-    ) as unknown as FerretNode[];
+    return this.db!.prepare('SELECT * FROM ferret_nodes WHERE status = ?').all(status) as unknown as FerretNode[];
   }
 
   async getContracts(): Promise<FerretContract[]> {
-    return this.db!.prepare(
-      "SELECT * FROM ferret_contracts",
-    ).all() as unknown as FerretContract[];
+    return this.db!.prepare('SELECT * FROM ferret_contracts').all() as unknown as FerretContract[];
   }
 
   async getContract(id: string): Promise<FerretContract | null> {
-    const row = this.db!.prepare(
-      "SELECT * FROM ferret_contracts WHERE id = ?",
-    ).get(id) as any;
+    const row = this.db!.prepare('SELECT * FROM ferret_contracts WHERE id = ?').get(id) as any;
     return row ?? null;
   }
 
   async getDependencies(): Promise<FerretDependency[]> {
-    return this.db!.prepare(
-      "SELECT * FROM ferret_dependencies",
-    ).all() as unknown as FerretDependency[];
+    return this.db!.prepare('SELECT * FROM ferret_dependencies').all() as unknown as FerretDependency[];
   }
 
   async updateNodeStatus(nodeId: string, status: NodeStatus): Promise<void> {
-    this.db!.prepare(
-      "UPDATE ferret_nodes SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
-    ).run(status, nodeId);
+    this.db!.prepare('UPDATE ferret_nodes SET status = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, nodeId);
   }
 
   async insertReconciliationLog(log: FerretReconciliationLog): Promise<void> {
@@ -239,40 +207,25 @@ export class SqliteStore implements DBStore {
       INSERT INTO ferret_reconciliation_log (id, node_id, triggered_by, resolved_by, resolution_notes)
       VALUES (?, ?, ?, ?, ?)
     `,
-    ).run(
-      log.id,
-      log.node_id,
-      log.triggered_by,
-      log.resolved_by ?? null,
-      log.resolution_notes ?? null,
-    );
+    ).run(log.id, log.node_id, log.triggered_by, log.resolved_by ?? null, log.resolution_notes ?? null);
   }
 
   async getReconciliationLogs(): Promise<FerretReconciliationLog[]> {
     return this.db!.prepare(
-      "SELECT id, node_id, triggered_by, resolved_by, resolution_notes FROM ferret_reconciliation_log",
+      'SELECT id, node_id, triggered_by, resolved_by, resolution_notes FROM ferret_reconciliation_log',
     ).all() as unknown as FerretReconciliationLog[];
   }
 
-  async insertPlacementDecision(
-    decision: FerretPlacementDecision,
-  ): Promise<void> {
+  async insertPlacementDecision(decision: FerretPlacementDecision): Promise<void> {
     this.db!.prepare(
       `
       INSERT INTO ferret_placement_decisions (id, node_id, placed_by, reasoning)
       VALUES (?, ?, ?, ?)
     `,
-    ).run(
-      decision.id,
-      decision.node_id,
-      decision.placed_by,
-      decision.reasoning ?? null,
-    );
+    ).run(decision.id, decision.node_id, decision.placed_by, decision.reasoning ?? null);
   }
 
   async getPlacementDecisions(): Promise<FerretPlacementDecision[]> {
-    return this.db!.prepare(
-      "SELECT id, node_id, placed_by, reasoning FROM ferret_placement_decisions",
-    ).all() as unknown as FerretPlacementDecision[];
+    return this.db!.prepare('SELECT id, node_id, placed_by, reasoning FROM ferret_placement_decisions').all() as unknown as FerretPlacementDecision[];
   }
 }

package/src/store/types.ts

@@ -1,5 +1,5 @@
-export type NodeStatus = "stable" | "needs-review" | "roadmap" | "blocked";
-export type ContractStatus = "stable" | "roadmap" | "needs-review";
+export type NodeStatus = 'stable' | 'needs-review' | 'roadmap' | 'blocked';
+export type ContractStatus = 'stable' | 'roadmap' | 'needs-review';
 
 export interface FerretNode {
   id: string;
@@ -16,6 +16,10 @@ export interface FerretContract {
   shape_schema: string;
   type: string;
   status: ContractStatus;
+  /** Path to the TypeScript file this contract was generated from (code-first contracts only). */
+  code_source_file?: string;
+  /** TypeScript symbol name this contract was generated from (code-first contracts only). */
+  code_source_symbol?: string;
 }
 
 export interface FerretDependency {
@@ -73,10 +77,7 @@ export interface DBStore {
   upsertDependency(dependency: FerretDependency): Promise<void>;
 
   /** Replaces all dependency edges for a source node with the provided targets */
-  replaceDependenciesForSourceNode(
-    sourceNodeId: string,
-    targetContractIds: string[],
-  ): Promise<void>;
+  replaceDependenciesForSourceNode(sourceNodeId: string, targetContractIds: string[]): Promise<void>;
 
   /** Full graph retrieval methods for the Reconciler engine */
   getNodes(): Promise<FerretNode[]>;