@learningnodes/elen 0.1.2 → 0.1.4

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@learningnodes/elen",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "AGPL-3.0",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@learningnodes/elen-core": "file:../core",
+    "@learningnodes/elen-core": "^0.1.4",
     "better-sqlite3": "^11.7.0",
     "nanoid": "^5.1.4"
   },
@@ -20,6 +20,7 @@
     "vitest": "^2.1.8"
   },
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./dist/index.js"
   }
-}
+}
+

package/client_test_output.txt

@@ -1,17 +0,0 @@
-
- RUN  v2.1.9 C:/Users/ln_ni/OneDrive/Desktop/Desktop/ventures/learningnodes/git/marketplace-repos/Elen/packages/sdk-ts
-
- Γ£ô tests/client.test.ts > ElenClient > logDecision creates a valid DecisionRecord
- Γ£ô tests/client.test.ts > ElenClient > logDecision throws if no constraints provided
- Γ£ô tests/client.test.ts > ElenClient > logDecision throws if no evidence provided
- Γ£ô tests/client.test.ts > ElenClient > logDecision auto-classifies epistemic types
- Γ£ô tests/client.test.ts > ElenClient > searchRecords filters by domain, minConfidence and parentPrompt
- Γ£ô tests/client.test.ts > ElenClient > competency profile is computed from records
- Γ£ô tests/client.test.ts > ElenClient > stores linked precedents in evidence
- Γ£ô tests/client.test.ts > ElenClient > ID generation produces unique IDs
-
- Test Files  1 passed (1)
-      Tests  8 passed (8)
-   Start at  12:18:15
-   Duration  2.30s (transform 471ms, setup 0ms, collect 666ms, tests 51ms, environment 1ms, prepare 546ms)
-

package/src/client.ts

@@ -1,172 +0,0 @@
-import {
-  minimalDecisionRecordSchema,
-  constraintSetSchema,
-  classifyEpistemicType,
-  type MinimalDecisionRecord,
-  type DecisionRecord,
-  type ConstraintSet,
-  type Constraint,
-  type Evidence,
-  type Check
-} from '@learningnodes/elen-core';
-import { createId, createDecisionId, createConstraintSetId } from './id';
-import type { StorageAdapter } from './storage';
-import type { CompetencyProfileResult, CommitDecisionInput, LogDecisionInput, SearchOptions } from './types';
-
-export class ElenClient {
-  constructor(private readonly agentId: string, private readonly storage: StorageAdapter) { }
-
-  async logDecision(input: LogDecisionInput): Promise<DecisionRecord> {
-    if (input.constraints.length === 0) throw new Error('Decision must include at least one constraint');
-    if (input.evidence.length === 0) throw new Error('Decision must include at least one evidence');
-
-    const decisionId = createDecisionId(input.domain);
-    const now = new Date().toISOString();
-
-    const constraintsSnapshot: Constraint[] = input.constraints.map((description, i) => ({
-      constraint_id: createId(`con${i}`),
-      decision_id: decisionId,
-      type: 'requirement',
-      description,
-      locked: false
-    }));
-
-    const evidenceSnapshot: Evidence[] = input.evidence.map((e, i) => ({
-      evidence_id: createId(`evd${i}`),
-      decision_id: decisionId,
-      type: input.linkedPrecedents?.[i] ? 'precedent' : 'observation',
-      claim: e,
-      proof: e,
-      confidence: input.confidence?.[i] ?? 0.8,
-      linked_precedent: input.linkedPrecedents?.[i]
-    }));
-
-    const checksSnapshot: Check[] = evidenceSnapshot.map((e, i) => ({
-      check_id: createId(`chk${i}`),
-      decision_id: decisionId,
-      claim: e.claim,
-      result: 'pass',
-      evidence_ids: [e.evidence_id],
-      epistemic_type: classifyEpistemicType(e),
-      confidence: e.confidence
-    }));
-
-    const record: DecisionRecord = {
-      record_id: createId('rec'),
-      decision_id: decisionId,
-      agent_id: this.agentId,
-      question: input.question,
-      answer: input.answer,
-      constraints_snapshot: constraintsSnapshot,
-      evidence_snapshot: evidenceSnapshot,
-      checks_snapshot: checksSnapshot,
-      confidence: evidenceSnapshot.reduce((a, e) => a + e.confidence, 0) / evidenceSnapshot.length,
-      validation_type: 'self',
-      domain: input.domain,
-      tags: [],
-      published_at: now,
-      expires_at: null
-    };
-
-    await this.storage.saveDecision?.({
-      decision_id: decisionId,
-      agent_id: this.agentId,
-      question: input.question,
-      domain: input.domain,
-      status: 'validated',
-      constraints: constraintsSnapshot,
-      evidence: evidenceSnapshot,
-      checks: checksSnapshot,
-      created_at: now,
-      parent_prompt: input.parentPrompt
-    });
-
-    await this.storage.saveLegacyRecord?.(record);
-    return record;
-  }
-
-  async commitDecision(input: CommitDecisionInput): Promise<MinimalDecisionRecord> {
-    const now = new Date().toISOString();
-
-    const constraintSetId = createConstraintSetId(input.constraints);
-    const existingConstraints = await this.storage.getConstraintSet(constraintSetId);
-
-    if (!existingConstraints) {
-      const newSet: ConstraintSet = {
-        constraint_set_id: constraintSetId,
-        atoms: input.constraints,
-        summary: `Auto-generated summary for ${input.constraints.length} constraints`
-      };
-      constraintSetSchema.parse(newSet);
-      await this.storage.saveConstraintSet(newSet);
-    }
-
-    const record: MinimalDecisionRecord = {
-      decision_id: createDecisionId(input.domain),
-      q_id: createId('q'),
-      question_text: input.question,
-      decision_text: input.decisionText,
-      constraint_set_id: constraintSetId,
-      refs: input.refs ?? [],
-      status: input.status ?? 'active',
-      supersedes_id: input.supersedesId,
-      timestamp: now,
-      agent_id: this.agentId,
-      domain: input.domain
-    };
-
-    minimalDecisionRecordSchema.parse(record);
-    await this.storage.saveRecord(record);
-
-    return record;
-  }
-
-  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<MinimalDecisionRecord> {
-    const oldRecord = await this.storage.getRecord(oldDecisionId);
-    if (oldRecord && 'status' in oldRecord) {
-      oldRecord.status = 'superseded';
-      await this.storage.saveRecord(oldRecord);
-    }
-
-    return this.commitDecision({ ...input, supersedesId: oldDecisionId });
-  }
-
-  async searchRecords(opts: SearchOptions) {
-    return this.storage.searchRecords(opts);
-  }
-
-  async searchPrecedents(query: string, opts: SearchOptions = {}) {
-    const direct = await this.storage.searchRecords({ ...opts, query });
-    if (direct.length > 0) return direct;
-    return this.storage.searchRecords({ ...opts, limit: opts.limit ?? 5 });
-  }
-
-  async suggest(opts: SearchOptions): Promise<Array<Partial<MinimalDecisionRecord>>> {
-    const fullRecords = await this.storage.searchRecords(opts);
-    return fullRecords
-      .filter((r): r is MinimalDecisionRecord => 'decision_text' in r)
-      .map((r) => ({
-        decision_id: r.decision_id,
-        status: r.status,
-        decision_text: r.decision_text,
-        question_text: r.question_text,
-        constraint_set_id: r.constraint_set_id,
-        refs: r.refs,
-        supersedes_id: r.supersedes_id
-      }));
-  }
-
-  async expand(decisionId: string): Promise<{ record: MinimalDecisionRecord, constraints: ConstraintSet } | null> {
-    const record = await this.storage.getRecord(decisionId);
-    if (!record || !('constraint_set_id' in record)) return null;
-
-    const constraints = await this.storage.getConstraintSet(record.constraint_set_id);
-    if (!constraints) return null;
-
-    return { record, constraints };
-  }
-
-  async getCompetencyProfile(): Promise<CompetencyProfileResult> {
-    return this.storage.getCompetencyProfile(this.agentId);
-  }
-}

package/src/id.ts

@@ -1,18 +0,0 @@
-import { randomBytes, createHash } from 'node:crypto';
-
-export function createId(prefix: string): string {
-  return `${prefix}-${randomBytes(8).toString('base64url').slice(0, 10)}`;
-}
-
-export function createDecisionId(domain: string): string {
-  // Analytical Prefix: 3 chars domain + 'A' (Agent) + 'T3' (Routine Tier)
-  const d = domain.toUpperCase().replace(/[^A-Z]/g, '').padEnd(3, 'X').substring(0, 3);
-  const prefix = `${d}AT3`;
-  return `dec:${prefix}-${randomBytes(4).toString('base64url').slice(0, 6)}`;
-}
-
-export function createConstraintSetId(atoms: string[]): string {
-  const sorted = [...atoms].sort().join('|');
-  const hash = createHash('sha256').update(sorted).digest('hex').substring(0, 8);
-  return `cs:${hash}`;
-}

package/src/index.ts

@@ -1,57 +0,0 @@
-import { ElenClient } from './client';
-import { InMemoryStorage, SQLiteStorage, type StorageAdapter } from './storage';
-import type { ElenConfig, CommitDecisionInput, LogDecisionInput, SearchOptions } from './types';
-
-export class Elen {
-  private readonly client: ElenClient;
-
-  constructor(config: ElenConfig) {
-    const storage = this.createStorage(config);
-    this.client = new ElenClient(config.agentId, storage);
-  }
-
-  private createStorage(config: ElenConfig): StorageAdapter {
-    if (config.storage === 'sqlite') {
-      return new SQLiteStorage(config.sqlitePath ?? 'elen.db', config.projectId, config.defaultProjectIsolation ?? 'strict');
-    }
-
-    return new InMemoryStorage();
-  }
-
-  async logDecision(input: LogDecisionInput) {
-    return this.client.logDecision(input);
-  }
-
-  async commitDecision(input: CommitDecisionInput) {
-    return this.client.commitDecision(input);
-  }
-
-  async supersedeDecision(oldDecisionId: string, input: CommitDecisionInput) {
-    return this.client.supersedeDecision(oldDecisionId, input);
-  }
-
-  async searchRecords(opts: SearchOptions) {
-    return this.client.searchRecords(opts);
-  }
-
-  async searchPrecedents(query: string, opts: SearchOptions = {}) {
-    return this.client.searchPrecedents(query, opts);
-  }
-
-  async suggest(opts: SearchOptions) {
-    return this.client.suggest(opts);
-  }
-
-  async expand(decisionId: string) {
-    return this.client.expand(decisionId);
-  }
-
-  async getCompetencyProfile() {
-    return this.client.getCompetencyProfile();
-  }
-}
-
-export * from './client';
-export * from './id';
-export * from './storage';
-export * from './types';

package/src/shims.d.ts

@@ -1,27 +0,0 @@
-declare module 'nanoid' {
-  export function nanoid(size?: number): string;
-}
-
-declare module 'better-sqlite3' {
-  interface Statement {
-    run(params?: unknown): unknown;
-    get(...params: unknown[]): unknown;
-    all(params?: unknown): unknown[];
-  }
-
-  interface DatabaseInstance {
-    exec(sql: string): void;
-    prepare(sql: string): Statement;
-  }
-
-  interface DatabaseConstructor {
-    new (path: string): DatabaseInstance;
-  }
-
-  const Database: DatabaseConstructor;
-  namespace Database {
-    export type Database = DatabaseInstance;
-  }
-
-  export default Database;
-}

package/src/storage/index.ts

@@ -1,3 +0,0 @@
-export * from './interface';
-export * from './memory';
-export * from './sqlite';

package/src/storage/interface.ts

@@ -1,20 +0,0 @@
-import type {
-  CompetencyProfile,
-  ConstraintSet,
-  DecisionContext,
-  DecisionRecord,
-  MinimalDecisionRecord
-} from '@learningnodes/elen-core';
-import type { SearchOptions } from '../types';
-
-export interface StorageAdapter {
-  saveDecision?(decision: DecisionContext): Promise<void>;
-  saveConstraintSet(constraintSet: ConstraintSet): Promise<void>;
-  getConstraintSet(id: string): Promise<ConstraintSet | null>;
-  saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void>;
-  saveLegacyRecord?(record: DecisionRecord): Promise<void>;
-  getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null>;
-  searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
-  getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>>;
-  getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
-}

package/src/storage/memory.ts

@@ -1,63 +0,0 @@
-import type {
-  CompetencyProfile,
-  ConstraintSet,
-  DecisionContext,
-  DecisionRecord,
-  MinimalDecisionRecord
-} from '@learningnodes/elen-core';
-import type { SearchOptions } from '../types';
-import type { StorageAdapter } from './interface';
-
-export class InMemoryStorage implements StorageAdapter {
-  private readonly constraintSets = new Map<string, ConstraintSet>();
-  private readonly records = new Map<string, MinimalDecisionRecord | DecisionRecord>();
-  private readonly decisions = new Map<string, DecisionContext>();
-
-  async saveDecision(decision: DecisionContext): Promise<void> { this.decisions.set(decision.decision_id, decision); }
-  async saveConstraintSet(constraintSet: ConstraintSet): Promise<void> { if (!this.constraintSets.has(constraintSet.constraint_set_id)) this.constraintSets.set(constraintSet.constraint_set_id, constraintSet); }
-  async getConstraintSet(id: string): Promise<ConstraintSet | null> { return this.constraintSets.get(id) ?? null; }
-  async saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void> { this.records.set(("record_id" in record ? record.record_id : record.decision_id), record); }
-  async saveLegacyRecord(record: DecisionRecord): Promise<void> { this.records.set(record.record_id, record); }
-  async getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null> { return this.records.get(recordId) ?? null; }
-
-  async searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>> {
-    let results = Array.from(this.records.values());
-    if (opts.domain) results = results.filter((r) => r.domain === opts.domain);
-    if (typeof opts.minConfidence === 'number') results = results.filter((r) => ('confidence' in r ? r.confidence >= opts.minConfidence! : true));
-    if (opts.parentPrompt) {
-      const needle = opts.parentPrompt.toLowerCase();
-      results = results.filter((r) => {
-        const ctx = this.decisions.get(r.decision_id);
-        return ctx?.parent_prompt?.toLowerCase().includes(needle) ?? false;
-      });
-    }
-    if (opts.query) {
-      const needle = opts.query.toLowerCase();
-      results = results.filter((r) => {
-        const haystack = 'decision_text' in r ? `${r.question_text ?? ''} ${r.decision_text} ${r.domain}` : `${r.question} ${r.answer} ${r.domain} ${r.constraints_snapshot.map(c=>c.description).join(' ')} ${r.evidence_snapshot.map(e=>`${e.claim} ${e.proof}`).join(' ')}`;
-        return haystack.toLowerCase().includes(needle);
-      });
-    }
-    const limit = opts.limit ?? results.length;
-    return results.slice(0, limit);
-  }
-
-  async getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>> {
-    return Array.from(this.records.values()).filter((r) => r.agent_id === agentId && (domain ? r.domain === domain : true));
-  }
-
-  async getCompetencyProfile(agentId: string): Promise<CompetencyProfile> {
-    const records = await this.getAgentDecisions(agentId);
-    const stats = new Map<string, {count:number; conf:number}>();
-    for (const r of records) {
-      const cur = stats.get(r.domain) ?? {count:0, conf:0};
-      cur.count += 1;
-      cur.conf += ("confidence" in r ? r.confidence : 0.8);
-      stats.set(r.domain, cur);
-    }
-    const domains = [...stats.keys()];
-    const strengths = domains.filter((d)=>{ const s=stats.get(d)!; return s.count >= 1 && (s.conf/s.count) >= 0.7;});
-    const weaknesses = domains.filter((d)=>{ const s=stats.get(d)!; return (s.conf/s.count) < 0.7;});
-    return { agent_id: agentId, domains, strengths, weaknesses, updated_at: new Date().toISOString() };
-  }
-}

package/src/storage/sqlite.ts

@@ -1,95 +0,0 @@
-import Database from 'better-sqlite3';
-import type { CompetencyProfile, ConstraintSet, DecisionContext, DecisionRecord, MinimalDecisionRecord } from '@learningnodes/elen-core';
-import type { SearchOptions } from '../types';
-import type { StorageAdapter } from './interface';
-
-export class SQLiteStorage implements StorageAdapter {
-  private readonly db: Database.Database;
-  private readonly projectId: string;
-  private readonly defaultIsolation: 'strict' | 'open';
-
-  constructor(path: string, projectId: string = 'default', defaultIsolation: 'strict' | 'open' = 'strict') {
-    this.db = new Database(path);
-    this.projectId = projectId;
-    this.defaultIsolation = defaultIsolation;
-    this.init();
-  }
-
-  private init() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS constraint_sets (constraint_set_id TEXT PRIMARY KEY, atoms TEXT NOT NULL, summary TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS decisions (decision_id TEXT PRIMARY KEY, decision_json TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS records (
-        record_id TEXT PRIMARY KEY,
-        decision_id TEXT,
-        agent_id TEXT NOT NULL,
-        domain TEXT NOT NULL,
-        project_id TEXT NOT NULL,
-        question_text TEXT,
-        decision_text TEXT,
-        confidence REAL,
-        payload_json TEXT NOT NULL
-      );
-    `);
-  }
-
-  async saveDecision(decision: DecisionContext): Promise<void> {
-    this.db.prepare('INSERT OR REPLACE INTO decisions(decision_id, decision_json) VALUES (?,?)').run([decision.decision_id, JSON.stringify(decision)]); 
-  }
-  async saveConstraintSet(constraintSet: ConstraintSet): Promise<void> {
-    this.db.prepare('INSERT OR IGNORE INTO constraint_sets(constraint_set_id, atoms, summary) VALUES (?,?,?)').run([constraintSet.constraint_set_id, JSON.stringify(constraintSet.atoms), constraintSet.summary]);
-  }
-  async getConstraintSet(id: string): Promise<ConstraintSet | null> {
-    const row = this.db.prepare('SELECT * FROM constraint_sets WHERE constraint_set_id=?').get(id) as any;
-    return row ? { constraint_set_id: row.constraint_set_id, atoms: JSON.parse(row.atoms), summary: row.summary } : null;
-  }
-  async saveRecord(record: MinimalDecisionRecord | DecisionRecord): Promise<void> {
-    if ("record_id" in record) {
-      await this.saveLegacyRecord(record);
-      return;
-    }
-    this.db.prepare('INSERT OR REPLACE INTO records(record_id, decision_id, agent_id, domain, project_id, question_text, decision_text, payload_json) VALUES (?,?,?,?,?,?,?,?)').run([record.decision_id, record.decision_id, record.agent_id, record.domain, this.projectId, record.question_text ?? null, record.decision_text, JSON.stringify(record)]);
-  }
-  async saveLegacyRecord(record: DecisionRecord): Promise<void> {
-    this.db.prepare('INSERT OR REPLACE INTO records(record_id, decision_id, agent_id, domain, project_id, question_text, decision_text, confidence, payload_json) VALUES (?,?,?,?,?,?,?,?,?)').run([record.record_id, record.decision_id, record.agent_id, record.domain, this.projectId, record.question, record.answer, record.confidence, JSON.stringify(record)]);
-  }
-  async getRecord(recordId: string): Promise<MinimalDecisionRecord | DecisionRecord | null> {
-    const row = this.db.prepare('SELECT payload_json FROM records WHERE record_id=? OR decision_id=?').get([recordId, recordId]) as any;
-    return row ? JSON.parse(row.payload_json) : null;
-  }
-  async searchRecords(opts: SearchOptions): Promise<Array<MinimalDecisionRecord | DecisionRecord>> {
-    let rows = this.db.prepare('SELECT payload_json, decision_id, project_id, confidence, question_text, decision_text, domain FROM records').all() as any[];
-    if (this.defaultIsolation === 'strict' || opts.includeShared === false) rows = rows.filter(r => r.project_id === this.projectId);
-    if (opts.domain) rows = rows.filter(r => r.domain === opts.domain);
-    if (typeof opts.minConfidence === 'number') rows = rows.filter(r => r.confidence == null || r.confidence >= opts.minConfidence!);
-    if (opts.query) {
-      const q=opts.query.toLowerCase();
-      rows=rows.filter(r => { const p = JSON.parse(r.payload_json); const extra = p.constraints_snapshot ? `${p.constraints_snapshot.map((c:any)=>c.description).join(' ')} ${p.evidence_snapshot.map((e:any)=>`${e.claim} ${e.proof}`).join(' ')}` : ''; return `${r.question_text ?? ''} ${r.decision_text ?? ''} ${r.domain ?? ''} ${extra}`.toLowerCase().includes(q); });
-    }
-    let parsed = rows.map(r => JSON.parse(r.payload_json));
-    if (opts.parentPrompt) {
-      const needle = opts.parentPrompt.toLowerCase();
-      parsed = parsed.filter((r: any) => {
-        const d = this.db.prepare('SELECT decision_json FROM decisions WHERE decision_id=?').get(r.decision_id) as any;
-        if (!d) return false;
-        const ctx = JSON.parse(d.decision_json) as DecisionContext;
-        return ctx.parent_prompt?.toLowerCase().includes(needle) ?? false;
-      });
-    }
-    return opts.limit ? parsed.slice(0, opts.limit) : parsed;
-  }
-  async getAgentDecisions(agentId: string, domain?: string): Promise<Array<MinimalDecisionRecord | DecisionRecord>> {
-    const rows = this.db.prepare('SELECT payload_json FROM records WHERE agent_id=?').all([agentId]) as any[];
-    const parsed = rows.map(r => JSON.parse(r.payload_json));
-    return domain ? parsed.filter(r => r.domain === domain) : parsed;
-  }
-  async getCompetencyProfile(agentId: string): Promise<CompetencyProfile> {
-    const records = await this.getAgentDecisions(agentId);
-    const stats = new Map<string, {count:number; conf:number}>();
-    for (const r of records) { const c=stats.get(r.domain) ?? {count:0, conf:0}; c.count +=1; c.conf += ("confidence" in r ? r.confidence : 0.8); stats.set(r.domain,c); }
-    const domains=[...stats.keys()];
-    const strengths=domains.filter(d=>{const s=stats.get(d)!; return (s.conf/s.count)>=0.7;});
-    const weaknesses=domains.filter(d=>{const s=stats.get(d)!; return (s.conf/s.count)<0.7;});
-    return { agent_id: agentId, domains, strengths, weaknesses, updated_at: new Date().toISOString() };
-  }
-}

package/src/types.ts

@@ -1,50 +0,0 @@
-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;
-  defaultProjectIsolation?: 'strict' | 'open';
-}
-
-export interface CommitDecisionInput {
-  question: string;
-  domain: string;
-  decisionText: string;
-  constraints: string[];
-  refs?: string[];
-  status?: DecisionStatus;
-  supersedesId?: string;
-}
-
-export interface LogDecisionInput {
-  question: string;
-  domain: string;
-  constraints: string[];
-  evidence: string[];
-  confidence?: number[];
-  answer: string;
-  parentPrompt?: string;
-  linkedPrecedents?: string[];
-}
-
-export interface SearchOptions {
-  domain?: string;
-  projectId?: string;
-  includeShared?: boolean;
-  query?: string;
-  limit?: number;
-  minConfidence?: number;
-  parentPrompt?: string;
-}
-
-export interface SearchPrecedentsOptions {
-  limit?: number;
-}
-
-export type DecisionRecordResult = DecisionRecord;
-export type CompetencyProfileResult = CompetencyProfile;
-export type ExpandedDecision = { record: DecisionRecord; constraints: ConstraintSet };

package/test_output.txt

@@ -1,78 +0,0 @@
-
- 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

@@ -1,147 +0,0 @@
-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);
-  });
-});

package/tests/integration.test.ts

@@ -1,49 +0,0 @@
-import { rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { describe, expect, it } from 'vitest';
-import { Elen } from '../src';
-
-describe('Elen integration', () => {
-  it('supports batch decision logging and precedent search in memory mode', async () => {
-    const elen = new Elen({ agentId: 'agent-int', storage: 'memory' });
-
-    const first = await elen.logDecision({
-      question: 'Which database for sessions?',
-      domain: 'infrastructure',
-      constraints: ['Must support >1000 writes'],
-      evidence: ['pgbench: PostgreSQL 3200 TPS vs SQLite 280 TPS'],
-      answer: 'PostgreSQL 16'
-    });
-
-    await elen.logDecision({
-      question: 'Which pooler?',
-      domain: 'infrastructure',
-      constraints: ['Must work with PostgreSQL'],
-      evidence: ['PostgreSQL selected per precedent'],
-      linkedPrecedents: [first.record_id],
-      answer: 'PgBouncer'
-    });
-
-    const precedents = await elen.searchPrecedents('high concurrency database selection');
-    expect(precedents.length).toBeGreaterThan(0);
-  });
-
-  it('supports sqlite-backed usage', async () => {
-    const dbPath = join(tmpdir(), `elen-int-${Date.now()}.db`);
-    const elen = new Elen({ agentId: 'agent-sql', storage: 'sqlite', sqlitePath: dbPath });
-
-    await elen.logDecision({
-      question: 'Which cache?',
-      domain: 'infrastructure',
-      constraints: ['Must be open-source'],
-      evidence: ['documentation recommends Redis for this workload'],
-      answer: 'Redis'
-    });
-
-    const records = await elen.searchRecords({ query: 'redis' });
-    expect(records).toHaveLength(1);
-
-    rmSync(dbPath, { force: true });
-  });
-});

package/tests/storage.test.ts

@@ -1,100 +0,0 @@
-import { rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { describe, expect, it } from 'vitest';
-import type { DecisionContext, DecisionRecord } from '@learningnodes/elen-core';
-import { InMemoryStorage, SQLiteStorage } from '../src/storage';
-
-function fixtures(): { context: DecisionContext; record: DecisionRecord } {
-  const decisionId = 'dec-1';
-  const context: DecisionContext = {
-    decision_id: decisionId,
-    agent_id: 'agent-a',
-    question: 'Which DB?',
-    domain: 'infrastructure',
-    status: 'validated',
-    constraints: [
-      {
-        constraint_id: 'con-1',
-        decision_id: decisionId,
-        type: 'requirement',
-        description: 'Must scale',
-        locked: false
-      }
-    ],
-    evidence: [
-      {
-        evidence_id: 'evd-1',
-        decision_id: decisionId,
-        type: 'benchmark',
-        claim: 'Postgres faster',
-        proof: 'benchmark 3200 TPS',
-        confidence: 0.9
-      }
-    ],
-    checks: [
-      {
-        check_id: 'chk-1',
-        decision_id: decisionId,
-        claim: 'Postgres faster',
-        result: 'pass',
-        evidence_ids: ['evd-1'],
-        epistemic_type: 'empirical',
-        confidence: 0.9
-      }
-    ],
-    created_at: new Date().toISOString(),
-    parent_prompt: 'Build auth system'
-  };
-
-  const record: DecisionRecord = {
-    record_id: 'rec-1',
-    decision_id: decisionId,
-    agent_id: 'agent-a',
-    question: 'Which DB?',
-    answer: 'PostgreSQL',
-    constraints_snapshot: context.constraints,
-    evidence_snapshot: context.evidence,
-    checks_snapshot: context.checks,
-    confidence: 0.9,
-    validation_type: 'self',
-    domain: 'infrastructure',
-    tags: ['database'],
-    published_at: new Date().toISOString(),
-    expires_at: null
-  };
-
-  return { context, record };
-}
-
-describe('Storage adapters', () => {
-  it('InMemoryStorage supports CRUD/search/profile', async () => {
-    const storage = new InMemoryStorage();
-    const { context, record } = fixtures();
-
-    await storage.saveDecision(context);
-    await storage.saveRecord(record);
-
-    expect(await storage.getRecord('rec-1')).not.toBeNull();
-    expect(await storage.searchRecords({ domain: 'infrastructure' })).toHaveLength(1);
-    expect(await storage.searchRecords({ parentPrompt: 'auth' })).toHaveLength(1);
-    expect((await storage.getCompetencyProfile('agent-a')).strengths).toContain('infrastructure');
-  });
-
-  it('SQLiteStorage supports CRUD/search/profile', async () => {
-    const dbPath = join(tmpdir(), `elen-sdk-${Date.now()}.db`);
-    const storage = new SQLiteStorage(dbPath);
-    const { context, record } = fixtures();
-
-    await storage.saveDecision(context);
-    await storage.saveRecord(record);
-
-    expect(await storage.getRecord('rec-1')).not.toBeNull();
-    expect(await storage.searchRecords({ domain: 'infrastructure' })).toHaveLength(1);
-    expect(await storage.searchRecords({ minConfidence: 0.8 })).toHaveLength(1);
-    expect(await storage.searchRecords({ parentPrompt: 'auth system' })).toHaveLength(1);
-    expect((await storage.getCompetencyProfile('agent-a')).domains).toContain('infrastructure');
-
-    rmSync(dbPath, { force: true });
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "baseUrl": "."
-  },
-  "include": ["src"]
-}