@learningnodes/elen 0.1.1

package/client_test_output.txt

@@ -0,0 +1,17 @@
+
+ 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/dist/client.d.ts

@@ -0,0 +1,16 @@
+import { type DecisionRecord, type ConstraintSet } from '@learningnodes/elen-core';
+import type { StorageAdapter } from './storage';
+import type { CompetencyProfileResult, CommitDecisionInput, SearchOptions } from './types';
+export declare class ElenClient {
+    private readonly agentId;
+    private readonly storage;
+    constructor(agentId: string, storage: StorageAdapter);
+    commitDecision(input: CommitDecisionInput): Promise<DecisionRecord>;
+    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<DecisionRecord>;
+    suggest(opts: SearchOptions): Promise<Partial<DecisionRecord>[]>;
+    expand(decisionId: string): Promise<{
+        record: DecisionRecord;
+        constraints: ConstraintSet;
+    } | null>;
+    getCompetencyProfile(): Promise<CompetencyProfileResult>;
+}

package/dist/client.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElenClient = void 0;
+const elen_core_1 = require("@learningnodes/elen-core");
+const id_1 = require("./id");
+class ElenClient {
+    constructor(agentId, storage) {
+        this.agentId = agentId;
+        this.storage = storage;
+    }
+    async commitDecision(input) {
+        const now = new Date().toISOString();
+        // 1. Resolve Constraints (Deterministic Hashing server-side)
+        const constraintSetId = (0, id_1.createConstraintSetId)(input.constraints);
+        const existingConstraints = await this.storage.getConstraintSet(constraintSetId);
+        if (!existingConstraints) {
+            const newSet = {
+                constraint_set_id: constraintSetId,
+                atoms: input.constraints,
+                summary: `Auto-generated summary for ${input.constraints.length} constraints`
+            };
+            elen_core_1.constraintSetSchema.parse(newSet);
+            await this.storage.saveConstraintSet(newSet);
+        }
+        // 2. Build the Minimal Decision Atom
+        const record = {
+            decision_id: (0, id_1.createDecisionId)(input.domain),
+            q_id: (0, id_1.createId)('q'),
+            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
+        };
+        elen_core_1.decisionRecordSchema.parse(record);
+        await this.storage.saveRecord(record);
+        return record;
+    }
+    async supersedeDecision(oldDecisionId, input) {
+        // 1. Mark old as superseded
+        const oldRecord = await this.storage.getRecord(oldDecisionId);
+        if (oldRecord) {
+            oldRecord.status = 'superseded';
+            await this.storage.saveRecord(oldRecord);
+        }
+        // 2. Commit new
+        return this.commitDecision({
+            ...input,
+            supersedesId: oldDecisionId
+        });
+    }
+    async suggest(opts) {
+        const fullRecords = await this.storage.searchRecords(opts);
+        // Pointer-first retrieval (minimal payload)
+        return fullRecords.map(r => ({
+            decision_id: r.decision_id,
+            status: r.status,
+            decision_text: r.decision_text,
+            constraint_set_id: r.constraint_set_id,
+            refs: r.refs,
+            supersedes_id: r.supersedes_id
+        }));
+    }
+    async expand(decisionId) {
+        const record = await this.storage.getRecord(decisionId);
+        if (!record)
+            return null;
+        const constraints = await this.storage.getConstraintSet(record.constraint_set_id);
+        if (!constraints)
+            return null;
+        return { record, constraints };
+    }
+    async getCompetencyProfile() {
+        return this.storage.getCompetencyProfile(this.agentId);
+    }
+}
+exports.ElenClient = ElenClient;

package/dist/id.d.ts

@@ -0,0 +1,3 @@
+export declare function createId(prefix: string): string;
+export declare function createDecisionId(domain: string): string;
+export declare function createConstraintSetId(atoms: string[]): string;

package/dist/id.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createId = createId;
+exports.createDecisionId = createDecisionId;
+exports.createConstraintSetId = createConstraintSetId;
+const node_crypto_1 = require("node:crypto");
+function createId(prefix) {
+    return `${prefix}-${(0, node_crypto_1.randomBytes)(8).toString('base64url').slice(0, 10)}`;
+}
+function createDecisionId(domain) {
+    // 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}-${(0, node_crypto_1.randomBytes)(4).toString('base64url').slice(0, 6)}`;
+}
+function createConstraintSetId(atoms) {
+    const sorted = [...atoms].sort().join('|');
+    const hash = (0, node_crypto_1.createHash)('sha256').update(sorted).digest('hex').substring(0, 8);
+    return `cs:${hash}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { ElenConfig, CommitDecisionInput, SearchOptions } from './types';
+export declare class Elen {
+    private readonly client;
+    constructor(config: ElenConfig);
+    private createStorage;
+    commitDecision(input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").DecisionRecord>;
+    supersedeDecision(oldDecisionId: string, input: CommitDecisionInput): Promise<import("@learningnodes/elen-core").DecisionRecord>;
+    suggest(opts: SearchOptions): Promise<Partial<import("@learningnodes/elen-core").DecisionRecord>[]>;
+    expand(decisionId: string): Promise<{
+        record: import("@learningnodes/elen-core").DecisionRecord;
+        constraints: import("@learningnodes/elen-core").ConstraintSet;
+    } | null>;
+    getCompetencyProfile(): Promise<import("@learningnodes/elen-core").CompetencyProfile>;
+}
+export * from './client';
+export * from './id';
+export * from './storage';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Elen = void 0;
+const client_1 = require("./client");
+const storage_1 = require("./storage");
+class Elen {
+    constructor(config) {
+        const storage = this.createStorage(config);
+        this.client = new client_1.ElenClient(config.agentId, storage);
+    }
+    createStorage(config) {
+        if (config.storage === 'sqlite') {
+            return new storage_1.SQLiteStorage(config.sqlitePath ?? 'elen.db', config.projectId);
+        }
+        return new storage_1.InMemoryStorage();
+    }
+    async commitDecision(input) {
+        return this.client.commitDecision(input);
+    }
+    async supersedeDecision(oldDecisionId, input) {
+        return this.client.supersedeDecision(oldDecisionId, input);
+    }
+    async suggest(opts) {
+        return this.client.suggest(opts);
+    }
+    async expand(decisionId) {
+        return this.client.expand(decisionId);
+    }
+    async getCompetencyProfile() {
+        return this.client.getCompetencyProfile();
+    }
+}
+exports.Elen = Elen;
+__exportStar(require("./client"), exports);
+__exportStar(require("./id"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./types"), exports);

package/dist/storage/index.d.ts

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

package/dist/storage/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./sqlite"), exports);

package/dist/storage/interface.d.ts

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

package/dist/storage/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/memory.d.ts

@@ -0,0 +1,14 @@
+import type { CompetencyProfile, ConstraintSet, DecisionRecord } from '@learningnodes/elen-core';
+import type { SearchOptions } from '../types';
+import type { StorageAdapter } from './interface';
+export declare class InMemoryStorage implements StorageAdapter {
+    private readonly constraintSets;
+    private readonly records;
+    saveConstraintSet(constraintSet: ConstraintSet): Promise<void>;
+    getConstraintSet(id: string): Promise<ConstraintSet | null>;
+    saveRecord(record: DecisionRecord): Promise<void>;
+    getRecord(recordId: string): Promise<DecisionRecord | null>;
+    searchRecords(opts: SearchOptions): Promise<DecisionRecord[]>;
+    getAgentDecisions(agentId: string, domain?: string): Promise<DecisionRecord[]>;
+    getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
+}

package/dist/storage/memory.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorage = void 0;
+class InMemoryStorage {
+    constructor() {
+        this.constraintSets = new Map();
+        this.records = new Map();
+    }
+    async saveConstraintSet(constraintSet) {
+        if (!this.constraintSets.has(constraintSet.constraint_set_id)) {
+            this.constraintSets.set(constraintSet.constraint_set_id, constraintSet);
+        }
+    }
+    async getConstraintSet(id) {
+        return this.constraintSets.get(id) ?? null;
+    }
+    async saveRecord(record) {
+        this.records.set(record.decision_id, record);
+    }
+    async getRecord(recordId) {
+        return this.records.get(recordId) ?? null;
+    }
+    async searchRecords(opts) {
+        let results = Array.from(this.records.values());
+        if (opts.domain) {
+            results = results.filter((record) => record.domain === opts.domain);
+        }
+        if (opts.query) {
+            const needle = opts.query.toLowerCase();
+            results = results.filter((record) => {
+                const haystack = [
+                    record.decision_text,
+                    record.domain,
+                    record.q_id
+                ].join(' ').toLowerCase();
+                return haystack.includes(needle);
+            });
+        }
+        const limit = opts.limit ?? results.length;
+        return results.sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, limit);
+    }
+    async getAgentDecisions(agentId, domain) {
+        return Array.from(this.records.values()).filter((record) => record.agent_id === agentId && (domain ? record.domain === domain : true));
+    }
+    async getCompetencyProfile(agentId) {
+        const records = await this.getAgentDecisions(agentId);
+        const domainCounts = new Map();
+        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 = [];
+        const weaknesses = [];
+        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()
+        };
+    }
+}
+exports.InMemoryStorage = InMemoryStorage;

package/dist/storage/sqlite.d.ts

@@ -0,0 +1,34 @@
+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 declare class SQLiteStorage implements StorageAdapter {
+    private readonly db;
+    private readonly projectId;
+    constructor(path: string, projectId?: string);
+    private init;
+    private ensureProject;
+    getProjects(): ProjectRecord[];
+    getSharing(): ProjectSharingRecord[];
+    upsertSharing(source: string, target: string, direction: 'one-way' | 'bi-directional', enabled: boolean): void;
+    deleteSharing(source: string, target: string): void;
+    private getAccessibleProjects;
+    saveConstraintSet(constraintSet: ConstraintSet): Promise<void>;
+    getConstraintSet(id: string): Promise<ConstraintSet | null>;
+    saveRecord(record: DecisionRecord): Promise<void>;
+    getRecord(recordId: string): Promise<DecisionRecord | null>;
+    searchRecords(opts: SearchOptions): Promise<DecisionRecord[]>;
+    getAgentDecisions(agentId: string, domain?: string): Promise<DecisionRecord[]>;
+    getCompetencyProfile(agentId: string): Promise<CompetencyProfile>;
+}