@ornexus/neocortex 4.60.71 → 4.60.73

package/packages/client/dist/state/structural-dag-projection.js

@@ -1 +1,118 @@
-class c extends Error{code;publicDetails;constructor(t,o){super(t),this.code=t,this.publicDetails=o,this.name="StructuralDagError"}}const g=1e4,m=5e4,U=1024,h=192*1024;function w(s){if(s.depends_on===void 0)return[];if(!Array.isArray(s.depends_on)||s.depends_on.some(t=>typeof t!="string"||t.length===0))throw new c("STRUCTURAL_DEPENDENCY_MISSING",{nodes:0,edges:0,malformedDependencies:1});return[...new Set(s.depends_on)].sort((t,o)=>t.localeCompare(o,"en"))}function L(s,t,o={}){const a=o.maxNodes??g,E=o.maxEdges??m,D=o.maxDepth??U,f=o.maxBytes??h,T=new Map,p=[];let n=0,r=0,_=0,i=0;const l=(e,d)=>{const u=T.get(e)??0;if(u===2)return;if(u===1)throw new c("STRUCTURAL_DEPENDENCY_CYCLE",{nodes:r,edges:n,cycles:1});const A=s[e];if(!A)throw new c("STRUCTURAL_DEPENDENCY_MISSING",{nodes:r,edges:n,missingDependencies:1});if(d>D)throw new c("STRUCTURAL_CONTEXT_TOO_LARGE",{nodes:r,edges:n,maxDepth:D,observedDepth:d});T.set(e,1),r+=1,i=Math.max(i,d);const C=w(A);if(_+=Buffer.byteLength(JSON.stringify({id:e,depends_on:C}),"utf8"),r>a)throw new c("STRUCTURAL_CONTEXT_TOO_LARGE",{nodes:r,edges:n,maxNodes:a,maxEdges:E});if(_>f)throw new c("STRUCTURAL_CONTEXT_TOO_LARGE",{nodes:r,edges:n,structuralBytes:_,maxBytes:f});for(const S of C){if(n+=1,n>E)throw new c("STRUCTURAL_CONTEXT_TOO_LARGE",{nodes:r,edges:n,maxNodes:a,maxEdges:E});l(S,d+1)}T.set(e,2),p.push(e)},R=t===void 0?Object.keys(s).sort((e,d)=>e.localeCompare(d,"en")):[...new Set(t)].sort((e,d)=>e.localeCompare(d,"en"));for(const e of R)l(e,1);return Object.freeze({orderedIds:Object.freeze(p),edgeCount:n,structuralBytes:_,maxDepth:i})}export{c as StructuralDagError,L as analyzeDependencyDag};
+export class StructuralDagError extends Error {
+    code;
+    publicDetails;
+    constructor(code, publicDetails) {
+        super(code);
+        this.code = code;
+        this.publicDetails = publicDetails;
+        this.name = 'StructuralDagError';
+    }
+}
+const DEFAULT_MAX_NODES = 10_000;
+const DEFAULT_MAX_EDGES = 50_000;
+const DEFAULT_MAX_DEPTH = 1_024;
+const DEFAULT_MAX_BYTES = 192 * 1024;
+function dependencyIds(node) {
+    if (node.depends_on === undefined)
+        return [];
+    if (!Array.isArray(node.depends_on)
+        || node.depends_on.some((value) => typeof value !== 'string' || value.length === 0)) {
+        throw new StructuralDagError('STRUCTURAL_DEPENDENCY_MISSING', {
+            nodes: 0,
+            edges: 0,
+            malformedDependencies: 1,
+        });
+    }
+    return [...new Set(node.depends_on)].sort((left, right) => left.localeCompare(right, 'en'));
+}
+/**
+ * Deterministic three-colour traversal used by YOLO and yoloop projections.
+ * Public diagnostics expose counts only; node names can contain customer data
+ * and must not escape through errors or telemetry.
+ */
+export function analyzeDependencyDag(nodes, roots, budgets = {}) {
+    const maxNodes = budgets.maxNodes ?? DEFAULT_MAX_NODES;
+    const maxEdges = budgets.maxEdges ?? DEFAULT_MAX_EDGES;
+    const depthBudget = budgets.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const byteBudget = budgets.maxBytes ?? DEFAULT_MAX_BYTES;
+    const colors = new Map();
+    const orderedIds = [];
+    let edgeCount = 0;
+    let visitedCount = 0;
+    let structuralBytes = 0;
+    let observedMaxDepth = 0;
+    const visit = (id, depth) => {
+        const color = colors.get(id) ?? 0;
+        if (color === 2)
+            return;
+        if (color === 1) {
+            throw new StructuralDagError('STRUCTURAL_DEPENDENCY_CYCLE', {
+                nodes: visitedCount,
+                edges: edgeCount,
+                cycles: 1,
+            });
+        }
+        const node = nodes[id];
+        if (!node) {
+            throw new StructuralDagError('STRUCTURAL_DEPENDENCY_MISSING', {
+                nodes: visitedCount,
+                edges: edgeCount,
+                missingDependencies: 1,
+            });
+        }
+        if (depth > depthBudget) {
+            throw new StructuralDagError('STRUCTURAL_CONTEXT_TOO_LARGE', {
+                nodes: visitedCount,
+                edges: edgeCount,
+                maxDepth: depthBudget,
+                observedDepth: depth,
+            });
+        }
+        colors.set(id, 1);
+        visitedCount += 1;
+        observedMaxDepth = Math.max(observedMaxDepth, depth);
+        const dependencies = dependencyIds(node);
+        structuralBytes += Buffer.byteLength(JSON.stringify({ id, depends_on: dependencies }), 'utf8');
+        if (visitedCount > maxNodes) {
+            throw new StructuralDagError('STRUCTURAL_CONTEXT_TOO_LARGE', {
+                nodes: visitedCount,
+                edges: edgeCount,
+                maxNodes,
+                maxEdges,
+            });
+        }
+        if (structuralBytes > byteBudget) {
+            throw new StructuralDagError('STRUCTURAL_CONTEXT_TOO_LARGE', {
+                nodes: visitedCount,
+                edges: edgeCount,
+                structuralBytes,
+                maxBytes: byteBudget,
+            });
+        }
+        for (const dependencyId of dependencies) {
+            edgeCount += 1;
+            if (edgeCount > maxEdges) {
+                throw new StructuralDagError('STRUCTURAL_CONTEXT_TOO_LARGE', {
+                    nodes: visitedCount,
+                    edges: edgeCount,
+                    maxNodes,
+                    maxEdges,
+                });
+            }
+            visit(dependencyId, depth + 1);
+        }
+        colors.set(id, 2);
+        orderedIds.push(id);
+    };
+    const selectedRoots = roots === undefined
+        ? Object.keys(nodes).sort((left, right) => left.localeCompare(right, 'en'))
+        : [...new Set(roots)].sort((left, right) => left.localeCompare(right, 'en'));
+    for (const root of selectedRoots)
+        visit(root, 1);
+    return Object.freeze({
+        orderedIds: Object.freeze(orderedIds),
+        edgeCount,
+        structuralBytes,
+        maxDepth: observedMaxDepth,
+    });
+}

package/packages/client/dist/telemetry/index.js

@@ -1 +1,5 @@
-import{OfflineTelemetryQueue as r}from"./offline-queue.js";export{r as OfflineTelemetryQueue};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ */
+export { OfflineTelemetryQueue } from './offline-queue.js';

package/packages/client/dist/telemetry/offline-queue.js

@@ -1 +1,131 @@
-import{readFile as a,writeFile as n,mkdir as r}from"node:fs/promises";import{dirname as u}from"node:path";import{join as c}from"node:path";import{homedir as o}from"node:os";const h={queueFilePath:c(o(),".neocortex",".telemetry-queue"),maxEvents:1e3,maxSizeBytes:5242880};class d{config;constructor(t){this.config={...h,...t}}async enqueue(t){try{const e=await this.loadQueue();for(e.push(t);e.length>this.config.maxEvents;)e.shift();let i=JSON.stringify(e);for(;Buffer.byteLength(i,"utf8")>this.config.maxSizeBytes&&e.length>0;)e.shift(),i=JSON.stringify(e);await this.saveQueue(e)}catch{}}async flush(t){try{const e=await this.loadQueue();return e.length===0?{sent:0,failed:0}:await t(e)?(await this.saveQueue([]),{sent:e.length,failed:0}):{sent:0,failed:e.length}}catch{return{sent:0,failed:0}}}async getStats(){try{const t=await this.loadQueue(),e=JSON.stringify(t);return{count:t.length,sizeBytes:Buffer.byteLength(e,"utf8")}}catch{return{count:0,sizeBytes:0}}}async clear(){try{await this.saveQueue([])}catch{}}async loadQueue(){try{const t=await a(this.config.queueFilePath,"utf8"),e=JSON.parse(t);return Array.isArray(e)?e:[]}catch{return[]}}async saveQueue(t){const e=u(this.config.queueFilePath);await r(e,{recursive:!0});const i=`${this.config.queueFilePath}.tmp`;await n(i,JSON.stringify(t),"utf8");const{rename:s}=await import("node:fs/promises");await s(i,this.config.queueFilePath)}}export{d as OfflineTelemetryQueue};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * This file is part of Neocortex CLI, licensed under the
+ * Functional Source License, Version 1.1 (FSL-1.1).
+ *
+ * Change Date: February 20, 2029
+ * Change License: MIT
+ *
+ * See the LICENSE file in the project root for full license text.
+ */
+/**
+ * @neocortex/client - Offline Telemetry Queue
+ *
+ * Persistent FIFO queue for telemetry events when the CLI operates offline.
+ * Events are stored in a JSON file and flushed when connection is restored.
+ * Respects configurable limits on event count (1000) and file size (5MB).
+ *
+ * Story 42.9
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+// ── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    queueFilePath: join(homedir(), '.neocortex', '.telemetry-queue'),
+    maxEvents: 1_000,
+    maxSizeBytes: 5_242_880, // 5MB
+};
+// ── OfflineTelemetryQueue ────────────────────────────────────────────────
+export class OfflineTelemetryQueue {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Add a telemetry event to the queue.
+     * Evicts oldest events if limits are reached.
+     */
+    async enqueue(event) {
+        try {
+            const events = await this.loadQueue();
+            events.push(event);
+            // Evict oldest events if count limit exceeded
+            while (events.length > this.config.maxEvents) {
+                events.shift();
+            }
+            // Evict oldest events if size limit exceeded
+            let serialized = JSON.stringify(events);
+            while (Buffer.byteLength(serialized, 'utf8') > this.config.maxSizeBytes && events.length > 0) {
+                events.shift();
+                serialized = JSON.stringify(events);
+            }
+            await this.saveQueue(events);
+        }
+        catch {
+            // Queue write failures are non-critical
+        }
+    }
+    /**
+     * Flush all queued events using the provided send function.
+     * Returns count of sent and failed events.
+     */
+    async flush(sendFn) {
+        try {
+            const events = await this.loadQueue();
+            if (events.length === 0) {
+                return { sent: 0, failed: 0 };
+            }
+            const success = await sendFn(events);
+            if (success) {
+                await this.saveQueue([]);
+                return { sent: events.length, failed: 0 };
+            }
+            return { sent: 0, failed: events.length };
+        }
+        catch {
+            return { sent: 0, failed: 0 };
+        }
+    }
+    /**
+     * Get queue statistics.
+     */
+    async getStats() {
+        try {
+            const events = await this.loadQueue();
+            const serialized = JSON.stringify(events);
+            return {
+                count: events.length,
+                sizeBytes: Buffer.byteLength(serialized, 'utf8'),
+            };
+        }
+        catch {
+            return { count: 0, sizeBytes: 0 };
+        }
+    }
+    /**
+     * Clear all queued events.
+     */
+    async clear() {
+        try {
+            await this.saveQueue([]);
+        }
+        catch {
+            // Clear failures are non-critical
+        }
+    }
+    // ── Private ─────────────────────────────────────────────────────────
+    async loadQueue() {
+        try {
+            const raw = await readFile(this.config.queueFilePath, 'utf8');
+            const data = JSON.parse(raw);
+            if (!Array.isArray(data))
+                return [];
+            return data;
+        }
+        catch {
+            return [];
+        }
+    }
+    async saveQueue(events) {
+        const dir = dirname(this.config.queueFilePath);
+        await mkdir(dir, { recursive: true });
+        const tmpPath = `${this.config.queueFilePath}.tmp`;
+        await writeFile(tmpPath, JSON.stringify(events), 'utf8');
+        const { rename } = await import('node:fs/promises');
+        await rename(tmpPath, this.config.queueFilePath);
+    }
+}

package/packages/client/dist/tier/index.js

@@ -1 +1,5 @@
-import{TierAwareClient as i}from"./tier-aware-client.js";export{i as TierAwareClient};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ */
+export { TierAwareClient, } from './tier-aware-client.js';