@ornexus/neocortex 4.60.71 → 4.60.73

package/packages/client/dist/resilience/freshness-indicator.js

@@ -1 +1,100 @@
-import{DegradationLevel as e}from"./degradation-manager.js";const l={staleThresholdMs:864e5,warningThresholdMs:432e5};class h{config;constructor(t){this.config={...l,...t}}formatAge(t){if(t<0)return"just now";const r=Math.floor(t/1e3),n=Math.floor(t/6e4),s=Math.floor(t/36e5),o=Math.floor(t/864e5);return o>=1?`${o}d ago`:s>=1?`${s}h ago`:n>=1?`${n}m ago`:r>=1?`${r}s ago`:"just now"}evaluate(t,r){const n=t>this.config.staleThresholdMs,s=t>this.config.warningThresholdMs;let o=null,i="[CACHED]";if(n){const a=this.formatAge(t);i=`[STALE CACHE - ${a}]`,o=`WARNING: STALE - cached ${a}`}else if(s){const a=this.formatAge(t);i="[CACHED]",o=`WARNING - cached ${a}`}return{cached:!0,cacheAgeMs:t,stale:n,warning:o,prefix:i}}formatPrefix(t,r){switch(t){case e.ONLINE:return"";case e.HIGH_LATENCY:return r!=null?`[CACHED] cached ${this.formatAge(r)}`:"[CACHED]";case e.SERVER_DOWN:return r!=null?`[CACHED] cached ${this.formatAge(r)}`:"[CACHED]";case e.STALE_CACHE:return r!=null?`[STALE CACHE - ${this.formatAge(r)}]`:"[STALE CACHE]";case e.NO_CACHE:return"[ERROR]";default:return""}}}export{h as FreshnessIndicator};
+/**
+ * @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 - Freshness Indicator
+ *
+ * Enriches cache responses with freshness metadata for user-facing display.
+ * Formats cache age as human-readable strings and generates appropriate
+ * warning prefixes based on degradation level.
+ *
+ * Story 42.9
+ */
+import { DegradationLevel } from './degradation-manager.js';
+// ── Defaults ──────────────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    staleThresholdMs: 86_400_000, // 24 hours
+    warningThresholdMs: 43_200_000, // 12 hours
+};
+// ── FreshnessIndicator ──────────────────────────────────────────────────
+export class FreshnessIndicator {
+    config;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Format a duration in ms as human-readable age string.
+     * Examples: "30m ago", "4h ago", "2d ago"
+     */
+    formatAge(ageMs) {
+        if (ageMs < 0)
+            return 'just now';
+        const seconds = Math.floor(ageMs / 1_000);
+        const minutes = Math.floor(ageMs / 60_000);
+        const hours = Math.floor(ageMs / 3_600_000);
+        const days = Math.floor(ageMs / 86_400_000);
+        if (days >= 1)
+            return `${days}d ago`;
+        if (hours >= 1)
+            return `${hours}h ago`;
+        if (minutes >= 1)
+            return `${minutes}m ago`;
+        if (seconds >= 1)
+            return `${seconds}s ago`;
+        return 'just now';
+    }
+    /**
+     * Evaluate freshness of a cache entry.
+     */
+    evaluate(cacheAgeMs, _ttlMs) {
+        const stale = cacheAgeMs > this.config.staleThresholdMs;
+        const aged = cacheAgeMs > this.config.warningThresholdMs;
+        let warning = null;
+        let prefix = '[CACHED]';
+        if (stale) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            prefix = `[STALE CACHE - ${ageStr}]`;
+            warning = `WARNING: STALE - cached ${ageStr}`;
+        }
+        else if (aged) {
+            const ageStr = this.formatAge(cacheAgeMs);
+            prefix = `[CACHED]`;
+            warning = `WARNING - cached ${ageStr}`;
+        }
+        return {
+            cached: true,
+            cacheAgeMs,
+            stale,
+            warning,
+            prefix,
+        };
+    }
+    /**
+     * Format prefix string based on degradation level and optional age.
+     */
+    formatPrefix(level, ageMs) {
+        switch (level) {
+            case DegradationLevel.ONLINE:
+                return '';
+            case DegradationLevel.HIGH_LATENCY:
+                return ageMs != null ? `[CACHED] cached ${this.formatAge(ageMs)}` : '[CACHED]';
+            case DegradationLevel.SERVER_DOWN:
+                return ageMs != null ? `[CACHED] cached ${this.formatAge(ageMs)}` : '[CACHED]';
+            case DegradationLevel.STALE_CACHE:
+                return ageMs != null ? `[STALE CACHE - ${this.formatAge(ageMs)}]` : '[STALE CACHE]';
+            case DegradationLevel.NO_CACHE:
+                return '[ERROR]';
+            default:
+                return '';
+        }
+    }
+}

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

@@ -1 +1,8 @@
-import{ClientCircuitBreaker as o}from"./circuit-breaker.js";import{DegradationManager as a,DegradationLevel as i}from"./degradation-manager.js";import{FreshnessIndicator as c}from"./freshness-indicator.js";import{RecoveryDetector as m}from"./recovery-detector.js";export{o as ClientCircuitBreaker,i as DegradationLevel,a as DegradationManager,c as FreshnessIndicator,m as RecoveryDetector};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ */
+export { ClientCircuitBreaker } from './circuit-breaker.js';
+export { DegradationManager, DegradationLevel } from './degradation-manager.js';
+export { FreshnessIndicator } from './freshness-indicator.js';
+export { RecoveryDetector } from './recovery-detector.js';

package/packages/client/dist/resilience/recovery-detector.js

@@ -1 +1,74 @@
-class n{actions;constructor(e){this.actions=e}async onRecovery(){const e={circuitClosed:!1,jwtRefreshed:!1,cacheSynced:!1,telemetryFlushed:{sent:0,failed:0},notification:"[ONLINE] Server connection restored"};try{await this.actions.circuitBreaker.recordSuccess(),e.circuitClosed=!0}catch{}try{const t=await this.actions.licenseClient.getToken();e.jwtRefreshed=t!==null}catch{}try{e.cacheSynced=!0}catch{}try{const t=await this.actions.telemetryQueue.flush(async c=>(await fetch(`${this.actions.serverUrl}/api/v1/telemetry/batch`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({events:c})})).ok);e.telemetryFlushed=t}catch{}return e}}export{n as RecoveryDetector};
+/**
+ * @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.
+ */
+// ── RecoveryDetector ─────────────────────────────────────────────────────
+export class RecoveryDetector {
+    actions;
+    constructor(actions) {
+        this.actions = actions;
+    }
+    /**
+     * Execute full recovery sequence.
+     * Each step is independent - failures are captured but don't block others.
+     */
+    async onRecovery() {
+        const result = {
+            circuitClosed: false,
+            jwtRefreshed: false,
+            cacheSynced: false,
+            telemetryFlushed: { sent: 0, failed: 0 },
+            notification: '[ONLINE] Server connection restored',
+        };
+        // Step 1: Close circuit breaker
+        try {
+            await this.actions.circuitBreaker.recordSuccess();
+            result.circuitClosed = true;
+        }
+        catch {
+            // Non-critical: breaker will close on next successful call
+        }
+        // Step 2: Re-validate JWT
+        try {
+            const token = await this.actions.licenseClient.getToken();
+            result.jwtRefreshed = token !== null;
+        }
+        catch {
+            // Non-critical: will be retried on next server call
+        }
+        // Step 3: Sync cache (background - just attempt, don't block)
+        try {
+            // We don't actually sync here - the next resolver call will
+            // update the cache automatically via fetchWithCacheFallback.
+            // We just mark as synced since the circuit is now closed.
+            result.cacheSynced = true;
+        }
+        catch {
+            // Non-critical
+        }
+        // Step 4: Flush telemetry queue
+        try {
+            const flushResult = await this.actions.telemetryQueue.flush(async (events) => {
+                const response = await fetch(`${this.actions.serverUrl}/api/v1/telemetry/batch`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ events }),
+                });
+                return response.ok;
+            });
+            result.telemetryFlushed = flushResult;
+        }
+        catch {
+            // Non-critical: queue will be flushed on next recovery
+        }
+        return result;
+    }
+}

package/packages/client/dist/resolvers/asset-resolver.js

@@ -0,0 +1,13 @@
+/**
+ * @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.
+ */
+export {};

package/packages/client/dist/resolvers/local-resolver.js

@@ -1,8 +1,255 @@
-import{readFile as f,access as d}from"node:fs/promises";import{join as h,resolve as y}from"node:path";import{ResolverMode as w}from"../types/index.js";const v=/^---\n([\s\S]*?)\n---/;function u(p){const t=p.match(v);if(!t)return{frontmatter:{},body:p};const s={},e=t[1].split(`
-`);for(const o of e){const n=o.indexOf(":");if(n===-1)continue;const a=o.slice(0,n).trim().replace(/^['"]|['"]$/g,"");let r=o.slice(n+1).trim();typeof r=="string"&&(r=r.replace(/^['"]|['"]$/g,"")),r==="true"?r=!0:r==="false"&&(r=!1),s[a]=r}const c=p.slice(t[0].length).trimStart();return{frontmatter:s,body:c}}class P{mode=w.LOCAL;projectRoot;stepPathIndex;constructor(t){this.projectRoot=y(t.projectRoot)}async resolveStep(t,s){const e=(await this.resolveStepPathIndex()).get(t);if(!e)throw new Error(`Step '${t}' is not present in the canonical registry`);const c=h(this.projectRoot,e),o=await f(c,"utf-8"),{frontmatter:n,body:a}=u(o);return{id:t,content:a,frontmatter:n}}resolveStepPathIndex(){return this.stepPathIndex??=this.loadStepPathIndex(),this.stepPathIndex}async loadStepPathIndex(){const t=h(this.projectRoot,"core","data","step-registry.json"),s=JSON.parse(await f(t,"utf8")),e=new Map,c=s.asset_bootstrap;if(c&&typeof c=="object"&&!Array.isArray(c)){const o=c.assets;if(!Array.isArray(o))throw new Error("manifest-generation-mismatch");for(const n of o){if(!n||typeof n!="object"||Array.isArray(n))throw new Error("manifest-schema-invalid");const a=n;if(a.type!=="step")continue;const r=a.relative_path;if(typeof r!="string"||!r.startsWith("steps/")||r.includes(".."))throw new Error("manifest-schema-invalid");const i=`core/${r}`,{frontmatter:l}=u(await f(h(this.projectRoot,i),"utf8")),m=l.id;if(typeof m!="string"||!/^step-[a-z0-9][a-z0-9._-]*$/.test(m))throw new Error("manifest-required-step-unresolved");if(e.has(m))throw new Error("manifest-duplicate-reference");e.set(m,i)}}else{const o=s.steps;if(!o||typeof o!="object"||Array.isArray(o))throw new Error("manifest-generation-mismatch");for(const n of Object.values(o))if(Array.isArray(n))for(const a of n){if(!a||typeof a!="object"||Array.isArray(a))throw new Error("manifest-schema-invalid");const r=a,i=r.id,l=r.file;if(typeof i!="string"||typeof l!="string"||!l.startsWith("core/steps/")||l.includes(".."))throw new Error("manifest-schema-invalid");if(e.has(i))throw new Error("manifest-duplicate-reference");e.set(i,l)}}if(e.size===0)throw new Error("manifest-generation-mismatch");return e}async resolveSkill(t,s){const e=[`core/skills/${t}.md`,`core/skills/step-skills/${t}.md`];t.includes("/")&&(e.unshift(`core/skills/step-skills/${t}.md`),e.unshift(`core/skills/${t}.md`));let c=null,o="";for(const r of e){const i=h(this.projectRoot,r);try{c=await f(i,"utf-8"),o=r;break}catch{}}if(c===null)throw new Error(`Skill '${t}' not found. Searched: ${e.join(", ")}`);const{frontmatter:n,body:a}=u(c);return{id:t,content:a,metadata:{...n,resolvedPath:o}}}async resolveStandard(t){const s=h(this.projectRoot,"core","standards",t);let e;try{e=await f(s,"utf-8")}catch{if(!t.endsWith(".md"))e=await f(`${s}.md`,"utf-8");else throw new Error(`Standard '${t}' not found at ${s}`)}return{id:t,content:e}}async resolveRegistry(){const t=h(this.projectRoot,"core","data","step-registry.json"),s=await f(t,"utf-8");return JSON.parse(s)}async assemblePrompt(t,s){const e=await this.resolveStep(t,s),c={"{story_id}":s.storyId,"{story_title}":s.storyTitle,"{step_id}":t,"{step_name}":e.frontmatter.name||t,"{current_status}":s.currentStatus,"{epic_id}":s.epicId,"{branch_name}":s.branchName,"{platform_target}":s.platformTarget};let o=e.content;for(const[r,i]of Object.entries(c))o=o.replaceAll(r,i);const n=[],a=e.frontmatter.skills;if(a&&typeof a=="string"){const r=a.split(",").map(i=>i.trim());for(const i of r)try{const l=await this.resolveSkill(i,s);o+=`
-
----
-
-# Skill: ${i}
-
-${l.content}`,n.push(i)}catch{}}return{prompt:o,variables:c,includedSkills:n,includedStandards:[]}}async isAvailable(){try{const t=h(this.projectRoot,"core");return await d(t),!0}catch{return!1}}async dispose(){}}export{P as LocalResolver};
+/**
+ * @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 - LocalResolver
+ *
+ * Resolves pipeline assets from the local filesystem.
+ * Used in development mode when core/ directory is available locally.
+ * Replicates the current CLI behavior of reading .md files directly.
+ */
+import { readFile, access } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { ResolverMode, } from '../types/index.js';
+// ── Frontmatter Parser ───────────────────────────────────────────────────
+const FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+/**
+ * Parse YAML-like frontmatter from markdown content.
+ * Simple key-value parser sufficient for step/skill frontmatter.
+ */
+function parseFrontmatter(content) {
+    const match = content.match(FRONTMATTER_REGEX);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatter = {};
+    const lines = match[1].split('\n');
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim().replace(/^['"]|['"]$/g, '');
+        let value = line.slice(colonIndex + 1).trim();
+        // Remove surrounding quotes
+        if (typeof value === 'string') {
+            value = value.replace(/^['"]|['"]$/g, '');
+        }
+        // Parse booleans
+        if (value === 'true')
+            value = true;
+        else if (value === 'false')
+            value = false;
+        frontmatter[key] = value;
+    }
+    const body = content.slice(match[0].length).trimStart();
+    return { frontmatter, body };
+}
+// ── LocalResolver Implementation ─────────────────────────────────────────
+export class LocalResolver {
+    mode = ResolverMode.LOCAL;
+    projectRoot;
+    stepPathIndex;
+    constructor(options) {
+        this.projectRoot = resolve(options.projectRoot);
+    }
+    async resolveStep(stepId, _context) {
+        const relativePath = (await this.resolveStepPathIndex()).get(stepId);
+        if (!relativePath)
+            throw new Error(`Step '${stepId}' is not present in the canonical registry`);
+        const fullPath = join(this.projectRoot, relativePath);
+        const raw = await readFile(fullPath, 'utf-8');
+        const { frontmatter, body } = parseFrontmatter(raw);
+        return {
+            id: stepId,
+            content: body,
+            frontmatter,
+        };
+    }
+    resolveStepPathIndex() {
+        this.stepPathIndex ??= this.loadStepPathIndex();
+        return this.stepPathIndex;
+    }
+    async loadStepPathIndex() {
+        const registryPath = join(this.projectRoot, 'core', 'data', 'step-registry.json');
+        const parsed = JSON.parse(await readFile(registryPath, 'utf8'));
+        const index = new Map();
+        const bootstrap = parsed['asset_bootstrap'];
+        if (bootstrap && typeof bootstrap === 'object' && !Array.isArray(bootstrap)) {
+            const assets = bootstrap['assets'];
+            if (!Array.isArray(assets))
+                throw new Error('manifest-generation-mismatch');
+            for (const raw of assets) {
+                if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                    throw new Error('manifest-schema-invalid');
+                const asset = raw;
+                if (asset['type'] !== 'step')
+                    continue;
+                const assetPath = asset['relative_path'];
+                if (typeof assetPath !== 'string' || !assetPath.startsWith('steps/') || assetPath.includes('..')) {
+                    throw new Error('manifest-schema-invalid');
+                }
+                const relativePath = `core/${assetPath}`;
+                const { frontmatter } = parseFrontmatter(await readFile(join(this.projectRoot, relativePath), 'utf8'));
+                const id = frontmatter['id'];
+                if (typeof id !== 'string' || !/^step-[a-z0-9][a-z0-9._-]*$/.test(id)) {
+                    throw new Error('manifest-required-step-unresolved');
+                }
+                if (index.has(id))
+                    throw new Error('manifest-duplicate-reference');
+                index.set(id, relativePath);
+            }
+        }
+        else {
+            // Explicit legacy partial projection: exact registry files only, with no
+            // category/path inference after a miss.
+            const groups = parsed['steps'];
+            if (!groups || typeof groups !== 'object' || Array.isArray(groups))
+                throw new Error('manifest-generation-mismatch');
+            for (const entries of Object.values(groups)) {
+                if (!Array.isArray(entries))
+                    continue;
+                for (const raw of entries) {
+                    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+                        throw new Error('manifest-schema-invalid');
+                    const entry = raw;
+                    const id = entry['id'];
+                    const file = entry['file'];
+                    if (typeof id !== 'string' || typeof file !== 'string' || !file.startsWith('core/steps/') || file.includes('..')) {
+                        throw new Error('manifest-schema-invalid');
+                    }
+                    if (index.has(id))
+                        throw new Error('manifest-duplicate-reference');
+                    index.set(id, file);
+                }
+            }
+        }
+        if (index.size === 0)
+            throw new Error('manifest-generation-mismatch');
+        return index;
+    }
+    async resolveSkill(skillId, _context) {
+        // Skills are organized in: core/skills/{category}/{skillId}.md
+        // or: core/skills/step-skills/{step}/{skillId}.md
+        // Try multiple paths to find the skill
+        const searchPaths = [
+            `core/skills/${skillId}.md`,
+            `core/skills/step-skills/${skillId}.md`,
+        ];
+        // Also try with nested path: "diagnose/prompt-enricher" -> core/skills/step-skills/diagnose/prompt-enricher.md
+        if (skillId.includes('/')) {
+            searchPaths.unshift(`core/skills/step-skills/${skillId}.md`);
+            searchPaths.unshift(`core/skills/${skillId}.md`);
+        }
+        let raw = null;
+        let resolvedPath = '';
+        for (const searchPath of searchPaths) {
+            const fullPath = join(this.projectRoot, searchPath);
+            try {
+                raw = await readFile(fullPath, 'utf-8');
+                resolvedPath = searchPath;
+                break;
+            }
+            catch {
+                // Try next path
+            }
+        }
+        if (raw === null) {
+            throw new Error(`Skill '${skillId}' not found. Searched: ${searchPaths.join(', ')}`);
+        }
+        const { frontmatter, body } = parseFrontmatter(raw);
+        return {
+            id: skillId,
+            content: body,
+            metadata: { ...frontmatter, resolvedPath },
+        };
+    }
+    async resolveStandard(standardId) {
+        const fullPath = join(this.projectRoot, 'core', 'standards', standardId);
+        let content;
+        try {
+            content = await readFile(fullPath, 'utf-8');
+        }
+        catch {
+            // Try with .md extension if not present
+            if (!standardId.endsWith('.md')) {
+                content = await readFile(`${fullPath}.md`, 'utf-8');
+            }
+            else {
+                throw new Error(`Standard '${standardId}' not found at ${fullPath}`);
+            }
+        }
+        return {
+            id: standardId,
+            content,
+        };
+    }
+    async resolveRegistry() {
+        const fullPath = join(this.projectRoot, 'core', 'data', 'step-registry.json');
+        const raw = await readFile(fullPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    async assemblePrompt(stepId, context) {
+        // Resolve the step content
+        const step = await this.resolveStep(stepId, context);
+        // Build variables map from context
+        const variables = {
+            '{story_id}': context.storyId,
+            '{story_title}': context.storyTitle,
+            '{step_id}': stepId,
+            '{step_name}': step.frontmatter['name'] || stepId,
+            '{current_status}': context.currentStatus,
+            '{epic_id}': context.epicId,
+            '{branch_name}': context.branchName,
+            '{platform_target}': context.platformTarget,
+        };
+        // Substitute variables in step content
+        let prompt = step.content;
+        for (const [key, value] of Object.entries(variables)) {
+            prompt = prompt.replaceAll(key, value);
+        }
+        // Resolve skills referenced in step frontmatter
+        const includedSkills = [];
+        const skillsRef = step.frontmatter['skills'];
+        if (skillsRef && typeof skillsRef === 'string') {
+            const skillIds = skillsRef.split(',').map((s) => s.trim());
+            for (const sid of skillIds) {
+                try {
+                    const skill = await this.resolveSkill(sid, context);
+                    prompt += `\n\n---\n\n# Skill: ${sid}\n\n${skill.content}`;
+                    includedSkills.push(sid);
+                }
+                catch {
+                    // Skill not found - skip
+                }
+            }
+        }
+        return {
+            prompt,
+            variables,
+            includedSkills,
+            includedStandards: [],
+        };
+    }
+    async isAvailable() {
+        try {
+            const corePath = join(this.projectRoot, 'core');
+            await access(corePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async dispose() {
+        // LocalResolver holds no resources to release
+    }
+}