@learningnodes/elen 0.1.1

package/src/storage/sqlite.ts

@@ -0,0 +1,397 @@
+import Database from 'better-sqlite3';
+import type { CompetencyProfile, DecisionRecord, ConstraintSet } from '@learningnodes/elen-core';
+import type { SearchOptions } from '../types';
+import type { StorageAdapter } from './interface';
+
+export interface ProjectRecord {
+  project_id: string;
+  display_name: string;
+  source_hint: string | null;
+  created_at: string;
+}
+
+export interface ProjectSharingRecord {
+  source_project_id: string;
+  target_project_id: string;
+  direction: 'one-way' | 'bi-directional';
+  enabled: number;
+}
+
+export class SQLiteStorage implements StorageAdapter {
+  private readonly db: Database.Database;
+  private readonly projectId: string;
+
+  constructor(path: string, projectId: string = 'default') {
+    this.db = new Database(path);
+    this.projectId = projectId;
+    this.init();
+  }
+
+  private init(): void {
+    const pragmaQuery = this.db.prepare('PRAGMA user_version').get() as { user_version: number };
+    const versionRow = pragmaQuery ? pragmaQuery.user_version : 0;
+
+    if (versionRow === 0) {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS constraint_sets (
+          constraint_set_id TEXT PRIMARY KEY,
+          atoms TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+  
+        CREATE TABLE IF NOT EXISTS records (
+          record_id TEXT PRIMARY KEY,
+          decision_id TEXT NOT NULL,
+          q_id TEXT NOT NULL,
+          agent_id TEXT NOT NULL,
+          domain TEXT NOT NULL,
+          project_id TEXT NOT NULL DEFAULT 'default',
+          decision_text TEXT NOT NULL,
+          constraint_set_id TEXT NOT NULL,
+          refs TEXT NOT NULL,
+          status TEXT NOT NULL,
+          supersedes_id TEXT,
+          timestamp TEXT NOT NULL,
+          record_json TEXT NOT NULL,
+          FOREIGN KEY(constraint_set_id) REFERENCES constraint_sets(constraint_set_id)
+        );
+  
+        CREATE TABLE IF NOT EXISTS projects (
+          project_id TEXT PRIMARY KEY,
+          display_name TEXT NOT NULL,
+          source_hint TEXT,
+          created_at TEXT NOT NULL
+        );
+  
+        CREATE TABLE IF NOT EXISTS project_sharing (
+          source_project_id TEXT NOT NULL,
+          target_project_id TEXT NOT NULL,
+          direction TEXT NOT NULL DEFAULT 'one-way',
+          enabled INTEGER NOT NULL DEFAULT 1,
+          PRIMARY KEY (source_project_id, target_project_id)
+        );
+  
+          CREATE TABLE IF NOT EXISTS search_log (
+            search_id INTEGER PRIMARY KEY AUTOINCREMENT,
+            query TEXT NOT NULL,
+            domain TEXT,
+            project_id TEXT NOT NULL,
+            hits INTEGER NOT NULL DEFAULT 0,
+            cross_project_hits INTEGER NOT NULL DEFAULT 0,
+            searched_at TEXT NOT NULL
+          );
+        `);
+    } else {
+      // Legacy migration: Database exists but lacks the v1 schema columns.
+      this.db.exec("BEGIN TRANSACTION;");
+      try {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS constraint_sets (
+              constraint_set_id TEXT PRIMARY KEY,
+              atoms TEXT NOT NULL,
+              summary TEXT NOT NULL,
+              created_at TEXT NOT NULL
+            );
+          `);
+
+        // Alter legacy records table to inject the new columns gracefully
+        const queries = [
+          "ALTER TABLE records ADD COLUMN q_id TEXT NOT NULL DEFAULT 'legacy_q'",
+          "ALTER TABLE records ADD COLUMN constraint_set_id TEXT NOT NULL DEFAULT 'legacy_c'",
+          "ALTER TABLE records ADD COLUMN refs TEXT NOT NULL DEFAULT '[]'",
+          "ALTER TABLE records ADD COLUMN status TEXT NOT NULL DEFAULT 'active'",
+          "ALTER TABLE records ADD COLUMN supersedes_id TEXT",
+          "ALTER TABLE records ADD COLUMN timestamp TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP",
+          "ALTER TABLE records ADD COLUMN decision_text TEXT NOT NULL DEFAULT ''"
+        ];
+
+        for (const query of queries) {
+          try {
+            this.db.exec(query);
+          } catch (e) {
+            // Ignore "duplicate column name" if partially migrated
+          }
+        }
+
+        // Migrate existing 'answer' data over to 'decision_text' if applicable
+        try {
+          this.db.exec("UPDATE records SET decision_text = answer WHERE decision_text = '' AND answer IS NOT NULL");
+        } catch (e) {
+          // 'answer' column might have been dropped or didn't exist
+        }
+        this.db.exec("COMMIT;");
+      } catch (e) {
+        this.db.exec("ROLLBACK;");
+        throw e;
+      }
+    }
+
+    this.db.exec('PRAGMA user_version = 1');
+
+    // Ensure current project exists in projects table
+    this.ensureProject(this.projectId);
+  }
+
+  private ensureProject(projectId: string, displayName?: string): void {
+    const existing = this.db
+      .prepare('SELECT project_id FROM projects WHERE project_id = ?')
+      .get(projectId);
+
+    if (!existing) {
+      this.db.prepare(`
+        INSERT INTO projects (project_id, display_name, source_hint, created_at)
+        VALUES (@project_id, @display_name, @source_hint, @created_at)
+      `).run({
+        project_id: projectId,
+        display_name: displayName || projectId.replace(/[-_]/g, ' ').replace(/\\b\\w/g, c => c.toUpperCase()),
+        source_hint: null,
+        created_at: new Date().toISOString()
+      });
+    }
+  }
+
+  // --- Project & Sharing Management ---
+
+  getProjects(): ProjectRecord[] {
+    return this.db.prepare('SELECT * FROM projects ORDER BY created_at ASC').all() as ProjectRecord[];
+  }
+
+  getSharing(): ProjectSharingRecord[] {
+    return this.db.prepare('SELECT * FROM project_sharing ORDER BY source_project_id').all() as ProjectSharingRecord[];
+  }
+
+  upsertSharing(source: string, target: string, direction: 'one-way' | 'bi-directional', enabled: boolean): void {
+    this.db.prepare(`
+      INSERT INTO project_sharing (source_project_id, target_project_id, direction, enabled)
+      VALUES (@source, @target, @direction, @enabled)
+      ON CONFLICT(source_project_id, target_project_id)
+      DO UPDATE SET direction = @direction, enabled = @enabled
+    `).run({ source, target, direction: direction, enabled: enabled ? 1 : 0 });
+  }
+
+  deleteSharing(source: string, target: string): void {
+    this.db.prepare('DELETE FROM project_sharing WHERE source_project_id = ? AND target_project_id = ?')
+      .run([source, target]);
+  }
+
+  private getAccessibleProjects(): string[] {
+    const hasRules = this.db.prepare(`
+      SELECT 1 FROM project_sharing
+      WHERE source_project_id = ? OR target_project_id = ?
+      LIMIT 1
+    `).get(this.projectId, this.projectId);
+
+    if (!hasRules) {
+      const all = this.db.prepare('SELECT project_id FROM projects').all() as Array<{ project_id: string }>;
+      const ids = new Set(all.map(r => r.project_id));
+      ids.add(this.projectId);
+      return [...ids];
+    }
+
+    const accessible = new Set<string>([this.projectId]);
+
+    const inbound = this.db.prepare(`
+      SELECT source_project_id FROM project_sharing
+      WHERE target_project_id = ? AND enabled = 1
+    `).all(this.projectId) as Array<{ source_project_id: string }>;
+
+    for (const row of inbound) {
+      accessible.add(row.source_project_id);
+    }
+
+    const bidir = this.db.prepare(`
+      SELECT source_project_id, target_project_id FROM project_sharing
+      WHERE direction = 'bi-directional' AND enabled = 1
+        AND (source_project_id = ? OR target_project_id = ?)
+    `).all([this.projectId, this.projectId]) as Array<{ source_project_id: string; target_project_id: string }>;
+
+    for (const row of bidir) {
+      accessible.add(row.source_project_id);
+      accessible.add(row.target_project_id);
+    }
+
+    return [...accessible];
+  }
+
+  // --- Core Storage Methods ---
+
+  async saveConstraintSet(constraintSet: ConstraintSet): Promise<void> {
+    const statement = this.db.prepare(`
+      INSERT OR IGNORE INTO constraint_sets (constraint_set_id, atoms, summary, created_at)
+      VALUES (@constraint_set_id, @atoms, @summary, @created_at)
+    `);
+
+    statement.run({
+      constraint_set_id: constraintSet.constraint_set_id,
+      atoms: JSON.stringify(constraintSet.atoms),
+      summary: constraintSet.summary,
+      created_at: new Date().toISOString()
+    });
+  }
+
+  async getConstraintSet(id: string): Promise<ConstraintSet | null> {
+    const row = this.db
+      .prepare('SELECT constraint_set_id, atoms, summary FROM constraint_sets WHERE constraint_set_id = ?')
+      .get(id) as { constraint_set_id: string; atoms: string; summary: string } | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      constraint_set_id: row.constraint_set_id,
+      atoms: JSON.parse(row.atoms) as string[],
+      summary: row.summary
+    };
+  }
+
+  async saveRecord(record: DecisionRecord): Promise<void> {
+    const statement = this.db.prepare(`
+      INSERT OR REPLACE INTO records (
+        record_id, decision_id, q_id, agent_id, domain, project_id, decision_text, 
+        constraint_set_id, refs, status, supersedes_id, timestamp, record_json
+      )
+      VALUES (
+        @record_id, @decision_id, @q_id, @agent_id, @domain, @project_id, @decision_text, 
+        @constraint_set_id, @refs, @status, @supersedes_id, @timestamp, @record_json
+      )
+    `);
+
+    const enrichedRecord = { ...record, project_id: this.projectId };
+
+    statement.run({
+      record_id: record.decision_id,
+      decision_id: record.decision_id,
+      q_id: record.q_id,
+      agent_id: record.agent_id,
+      domain: record.domain,
+      project_id: this.projectId,
+      decision_text: record.decision_text,
+      constraint_set_id: record.constraint_set_id,
+      refs: JSON.stringify(record.refs),
+      status: record.status,
+      supersedes_id: record.supersedes_id ?? null,
+      timestamp: record.timestamp,
+      record_json: JSON.stringify(enrichedRecord)
+    });
+  }
+
+  async getRecord(recordId: string): Promise<DecisionRecord | null> {
+    const row = this.db
+      .prepare('SELECT record_json FROM records WHERE decision_id = ?')
+      .get(recordId) as { record_json: string } | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return JSON.parse(row.record_json) as DecisionRecord;
+  }
+
+  async searchRecords(opts: SearchOptions): Promise<DecisionRecord[]> {
+    const conditions: string[] = [];
+    const params: Record<string, unknown> = {};
+
+    if (opts.includeShared !== false) {
+      const accessible = this.getAccessibleProjects();
+      const placeholders = accessible.map((_, i) => `@proj${i}`);
+      conditions.push(`records.project_id IN (${placeholders.join(', ')})`);
+      accessible.forEach((id, i) => { params[`proj${i}`] = id; });
+    } else {
+      const projId = opts.projectId || this.projectId;
+      conditions.push('records.project_id = @projectId');
+      params.projectId = projId;
+    }
+
+    if (opts.domain) {
+      conditions.push('records.domain = @domain');
+      params.domain = opts.domain;
+    }
+
+    if (opts.query) {
+      conditions.push(`(
+        LOWER(records.decision_text) LIKE @query OR
+        LOWER(records.domain) LIKE @query OR
+        LOWER(records.q_id) LIKE @query
+      )`);
+      params.query = `%${opts.query.toLowerCase()}%`;
+    }
+
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limitClause = opts.limit ? `LIMIT ${Math.max(1, opts.limit)}` : '';
+
+    const rows = this.db
+      .prepare(
+        `SELECT records.record_json FROM records
+         ${whereClause}
+         ORDER BY records.timestamp DESC
+         ${limitClause}`
+      )
+      .all(params) as Array<{ record_json: string }>;
+
+    const results = rows.map((row) => JSON.parse(row.record_json) as DecisionRecord);
+
+    try {
+      const crossProjectHits = results.filter((r: DecisionRecord & { project_id?: string }) => {
+        return r.project_id && r.project_id !== this.projectId;
+      }).length;
+
+      this.db.prepare(`
+        INSERT INTO search_log(query, domain, project_id, hits, cross_project_hits, searched_at)
+        VALUES(@query, @domain, @project_id, @hits, @cross_project_hits, @searched_at)
+      `).run({
+        query: opts.query || '',
+        domain: opts.domain || null,
+        project_id: this.projectId,
+        hits: results.length,
+        cross_project_hits: crossProjectHits,
+        searched_at: new Date().toISOString()
+      });
+    } catch {
+      // Non-critical: don't fail search if logging fails
+    }
+
+    return results;
+  }
+
+  async getAgentDecisions(agentId: string, domain?: string): Promise<DecisionRecord[]> {
+    const statement = domain
+      ? this.db.prepare(
+        'SELECT record_json FROM records WHERE agent_id = @agentId AND domain = @domain ORDER BY timestamp DESC'
+      )
+      : this.db.prepare('SELECT record_json FROM records WHERE agent_id = @agentId ORDER BY timestamp DESC');
+
+    const rows = statement.all({ agentId, domain }) as Array<{ record_json: string }>;
+    return rows.map((row) => JSON.parse(row.record_json) as DecisionRecord);
+  }
+
+  async getCompetencyProfile(agentId: string): Promise<CompetencyProfile> {
+    const records = await this.getAgentDecisions(agentId);
+    const domainCounts = new Map<string, number>();
+
+    for (const record of records) {
+      const count = domainCounts.get(record.domain) ?? 0;
+      domainCounts.set(record.domain, count + 1);
+    }
+
+    const domains = Array.from(domainCounts.keys());
+    const strengths: string[] = [];
+    const weaknesses: string[] = [];
+
+    // Simply map domain frequency to strengths
+    for (const [domain, count] of domainCounts.entries()) {
+      if (count >= 5) {
+        strengths.push(domain);
+      }
+    }
+
+    return {
+      agent_id: agentId,
+      domains,
+      strengths,
+      weaknesses,
+      updated_at: new Date().toISOString()
+    };
+  }
+}

package/src/types.ts

@@ -0,0 +1,35 @@
+import type { CompetencyProfile, DecisionRecord, DecisionStatus, ConstraintSet } from '@learningnodes/elen-core';
+
+export interface ElenConfig {
+  agentId: string;
+  projectId?: string;
+  storage?: 'memory' | 'sqlite';
+  sqlitePath?: string;
+  apiUrl?: string;
+  apiKey?: string;
+}
+
+export interface CommitDecisionInput {
+  question: string;
+  domain: string;
+  decisionText: string;
+  constraints: string[];
+  refs?: string[];
+  status?: DecisionStatus;
+  supersedesId?: string;
+}
+
+export interface SearchOptions {
+  domain?: string;
+  projectId?: string;
+  includeShared?: boolean;
+  query?: string;
+  limit?: number;
+}
+
+export interface SearchPrecedentsOptions {
+  limit?: number;
+}
+
+export type DecisionRecordResult = DecisionRecord;
+export type CompetencyProfileResult = CompetencyProfile;

package/test_output.txt

@@ -0,0 +1,78 @@
+
+ RUN  v2.1.9 C:/Users/ln_ni/OneDrive/Desktop/Desktop/ventures/learningnodes/git/marketplace-repos/Elen/packages/sdk-ts
+
+ Γ¥» tests/integration.test.ts (2 tests | 2 failed) 52ms
+   × Elen integration > supports batch decision logging and precedent search in memory mode 11ms
+     → expected 0 to be greater than 0
+   × Elen integration > supports sqlite-backed usage 39ms
+     → EBUSY: resource busy or locked, unlink 'C:\Users\ln_ni\AppData\Local\Temp\elen-int-1771463766853.db'
+
+node.exe : ⎯⎯⎯⎯⎯⎯⎯ 
+Failed Tests 2 
+⎯⎯⎯⎯⎯⎯⎯
+At C:\Users\ln_ni\AppData\Roaming\npm\npx.ps1:24 
+char:5
++     & "node$exe"  
+"$basedir/node_modules/npm/bin/npx-cli.js" $args
++     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~
+    + CategoryInfo          : NotSpecified: ([3 
+   1mΓÄ»ΓÄ»ΓÄ»Γ...»ΓÄ»ΓÄ»ΓÄ»:String) [], R  
+  emoteException
+    + FullyQualifiedErrorId : NativeCommandError
+ 
+
+ FAIL  
+tests/integration.test.ts > Elen 
+integration > supports batch decision 
+logging and precedent search in memory mode
+AssertionError: expected 0 to be 
+greater than 0
+ Γ¥» 
+tests/integration.test.ts:29:31
+     27| 
+     28|     const 
+precedents = await elen.
+searchPrecedents('high 
+concurrency d…
+     29|     expect(precedent
+s.length).toBeGreaterTha
+n(0);
+       |                               
+^
+     30|   });
+     31| 
+
+ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»Γ
+Ä»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»[1/2]ΓÄ»[39
+m
+
+ FAIL  
+tests/integration.test.ts > Elen 
+integration > supports sqlite-backed 
+usage
+Error: EBUSY: resource busy or 
+locked, unlink 'C:\Users\ln_ni\AppData\Local\Temp
+\elen-int-1771463766853.db'
+ Γ¥» 
+tests/integration.test.ts:47:5
+     45|     expect(records)
+[33m.toHaveLength(1)[33
+m;
+     46| 
+     47|     
+rmSync(dbPath, { 
+force: true });
+       |     ^
+     48|   });
+     49| });
+
+ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»Γ
+Ä»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»ΓÄ»[2/2]ΓÄ»[39
+m
+
+ Test Files  1 failed (1)
+      Tests  2 failed (2)
+   Start at  12:16:06
+   Duration  619ms (transform 125ms, setup 0ms, collect 193ms, tests 52ms, environment 0ms, prepare 118ms)
+

package/tests/client.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from 'vitest';
+import { ElenClient } from '../src/client';
+import { createId } from '../src/id';
+import { InMemoryStorage } from '../src/storage';
+
+describe('ElenClient', () => {
+  it('logDecision creates a valid DecisionRecord', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    const record = await client.logDecision({
+      question: 'Which DB?',
+      domain: 'infrastructure',
+      constraints: ['Must be open-source'],
+      evidence: ['benchmark: PostgreSQL 3200 TPS'],
+      answer: 'PostgreSQL'
+    });
+
+    expect(record.record_id.startsWith('rec-')).toBe(true);
+    expect(record.validation_type).toBe('self');
+    expect(record.constraints_snapshot).toHaveLength(1);
+    expect(record.evidence_snapshot).toHaveLength(1);
+    expect(record.checks_snapshot).toHaveLength(1);
+  });
+
+  it('logDecision throws if no constraints provided', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    await expect(
+      client.logDecision({
+        question: 'Which DB?',
+        domain: 'infrastructure',
+        constraints: [],
+        evidence: ['benchmark evidence'],
+        answer: 'PostgreSQL'
+      })
+    ).rejects.toThrow('at least one constraint');
+  });
+
+  it('logDecision throws if no evidence provided', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    await expect(
+      client.logDecision({
+        question: 'Which DB?',
+        domain: 'infrastructure',
+        constraints: ['Must scale'],
+        evidence: [],
+        answer: 'PostgreSQL'
+      })
+    ).rejects.toThrow('at least one evidence');
+  });
+
+  it('logDecision auto-classifies epistemic types', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    const record = await client.logDecision({
+      question: 'Which DB?',
+      domain: 'infrastructure',
+      constraints: ['Scale'],
+      evidence: ['benchmark measured 3200 TPS'],
+      answer: 'PostgreSQL'
+    });
+
+    expect(record.checks_snapshot[0].epistemic_type).toBe('empirical');
+  });
+
+  it('searchRecords filters by domain, minConfidence and parentPrompt', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    await client.logDecision({
+      question: 'Which DB?',
+      domain: 'infrastructure',
+      parentPrompt: 'Build auth system',
+      constraints: ['Scale'],
+      evidence: ['benchmark 3200 TPS'],
+      answer: 'PostgreSQL'
+    });
+
+    await client.logDecision({
+      question: 'Which color?',
+      domain: 'design',
+      parentPrompt: 'Design system refresh',
+      constraints: ['Accessible'],
+      evidence: ['usually blue works'],
+      confidence: [0.5],
+      answer: 'Blue'
+    });
+
+    const byDomain = await client.searchRecords({ domain: 'infrastructure' });
+    const byConfidence = await client.searchRecords({ minConfidence: 0.8 });
+    const byParent = await client.searchRecords({ parentPrompt: 'auth system' });
+
+    expect(byDomain).toHaveLength(1);
+    expect(byConfidence).toHaveLength(1);
+    expect(byParent).toHaveLength(1);
+    expect(byParent[0].domain).toBe('infrastructure');
+  });
+
+  it('competency profile is computed from records', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    await client.logDecision({
+      question: 'DB?',
+      domain: 'infrastructure',
+      constraints: ['Scale'],
+      evidence: ['benchmark 3200 TPS'],
+      confidence: [0.9],
+      answer: 'PostgreSQL'
+    });
+
+    await client.logDecision({
+      question: 'UI color?',
+      domain: 'design',
+      constraints: ['Accessible'],
+      evidence: ['rule of thumb says blue'],
+      confidence: [0.5],
+      answer: 'Blue'
+    });
+
+    const profile = await client.getCompetencyProfile();
+
+    expect(profile.domains).toEqual(expect.arrayContaining(['infrastructure', 'design']));
+    expect(profile.strengths).toContain('infrastructure');
+    expect(profile.weaknesses).toContain('design');
+  });
+
+  it('stores linked precedents in evidence', async () => {
+    const client = new ElenClient('agent-a', new InMemoryStorage());
+
+    const record = await client.logDecision({
+      question: 'Which pooler?',
+      domain: 'infrastructure',
+      constraints: ['Must work with PostgreSQL'],
+      evidence: ['PostgreSQL selected per precedent'],
+      linkedPrecedents: ['rec-abc123'],
+      answer: 'PgBouncer'
+    });
+
+    expect(record.evidence_snapshot[0].linked_precedent).toBe('rec-abc123');
+    expect(record.evidence_snapshot[0].type).toBe('precedent');
+  });
+
+  it('ID generation produces unique IDs', () => {
+    const ids = new Set(Array.from({ length: 300 }, () => createId('rec')));
+    expect(ids.size).toBe(300);
+  });
+});