cognitive-modules-cli 2.2.1 → 2.2.7

package/dist/server/http.js

@@ -13,24 +13,65 @@
 import http from 'node:http';
 import { URL } from 'node:url';
 import { findModule, listModules, getDefaultSearchPaths } from '../modules/loader.js';
-import { runModule } from '../modules/runner.js';
+import { runModule, runModuleStream } from '../modules/runner.js';
 import { getProvider } from '../providers/index.js';
+import { VERSION } from '../version.js';
+import { ErrorCodes, attachContext, makeErrorEnvelope, makeHttpError, httpStatusForErrorCode } from '../errors/index.js';
+import { encodeSseFrame } from './sse.js';
+// Supported protocol versions
+const SUPPORTED_VERSIONS = ['2.2'];
+const DEFAULT_VERSION = '2.2';
+/**
+ * Get requested protocol version from request
+ * Priority: body.version > X-Cognitive-Version header > query param > default
+ */
+function getRequestedVersion(req, url, bodyVersion) {
+    // Body version takes priority
+    if (bodyVersion && SUPPORTED_VERSIONS.includes(bodyVersion)) {
+        return bodyVersion;
+    }
+    // Check header
+    const headerVersion = req.headers['x-cognitive-version'];
+    if (headerVersion && SUPPORTED_VERSIONS.includes(headerVersion)) {
+        return headerVersion;
+    }
+    // Check query param
+    const queryVersion = url.searchParams.get('version');
+    if (queryVersion && SUPPORTED_VERSIONS.includes(queryVersion)) {
+        return queryVersion;
+    }
+    return DEFAULT_VERSION;
+}
 // =============================================================================
 // Helpers
 // =============================================================================
-function jsonResponse(res, status, data) {
+function jsonResponse(res, status, data, protocolVersion = DEFAULT_VERSION) {
     res.writeHead(status, {
         'Content-Type': 'application/json',
         'Access-Control-Allow-Origin': '*',
         'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Cognitive-Version',
+        'X-Cognitive-Version': protocolVersion,
     });
     res.end(JSON.stringify(data, null, 2));
 }
-function parseBody(req) {
+const MAX_BODY_BYTES = 1024 * 1024; // 1MB
+function parseBody(req, maxBytes = MAX_BODY_BYTES) {
     return new Promise((resolve, reject) => {
         let body = '';
-        req.on('data', (chunk) => (body += chunk));
+        let received = 0;
+        req.on('data', (chunk) => {
+            const chunkSize = typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk.length;
+            received += chunkSize;
+            if (received > maxBytes) {
+                const err = new Error('Payload too large');
+                err.code = 'PAYLOAD_TOO_LARGE';
+                req.destroy(err);
+                reject(err);
+                return;
+            }
+            body += chunk;
+        });
         req.on('end', () => resolve(body));
         req.on('error', reject);
     });
@@ -51,7 +92,16 @@ function verifyApiKey(req) {
 async function handleRoot(res) {
     jsonResponse(res, 200, {
         name: 'Cognitive Modules API',
-        version: '1.3.0',
+        version: VERSION,
+        protocol: {
+            version: DEFAULT_VERSION,
+            supported: SUPPORTED_VERSIONS,
+            negotiation: {
+                header: 'X-Cognitive-Version',
+                query: '?version=2.2',
+                body: 'version field in request body',
+            },
+        },
         docs: '/docs',
         endpoints: {
             run: 'POST /run',
@@ -72,7 +122,7 @@ async function handleHealth(res) {
     };
     jsonResponse(res, 200, {
         status: 'healthy',
-        version: '1.3.0',
+        version: VERSION,
         providers,
     });
 }
@@ -95,7 +145,12 @@ async function handleModules(res, searchPaths) {
 async function handleModuleInfo(res, moduleName, searchPaths) {
     const moduleData = await findModule(moduleName, searchPaths);
     if (!moduleData) {
-        jsonResponse(res, 404, { error: `Module '${moduleName}' not found` });
+        const envelope = makeErrorEnvelope({
+            code: ErrorCodes.MODULE_NOT_FOUND,
+            message: `Module '${moduleName}' not found`,
+            suggestion: 'Use GET /modules to list available modules',
+        });
+        jsonResponse(res, 404, envelope);
         return;
     }
     jsonResponse(res, 200, {
@@ -110,12 +165,30 @@ async function handleModuleInfo(res, moduleName, searchPaths) {
         outputSchema: moduleData.outputSchema,
     });
 }
-async function handleRun(req, res, searchPaths) {
+async function handleRun(req, res, searchPaths, url) {
+    // Version will be determined after parsing body
+    let protocolVersion = DEFAULT_VERSION;
+    // Helper to build error envelope using unified error factory
+    const buildHttpError = (code, message, options = {}) => {
+        const moduleName = options.moduleName ?? request?.module ?? 'unknown';
+        const providerName = options.providerName ?? request?.provider ?? 'unknown';
+        const [status, envelope] = makeHttpError({
+            code,
+            message,
+            version: protocolVersion,
+            suggestion: options.suggestion,
+            recoverable: options.recoverable,
+            retry_after_ms: options.retry_after_ms,
+            module: moduleName,
+            provider: providerName,
+        });
+        return [status, envelope];
+    };
     // Verify API key
     if (!verifyApiKey(req)) {
-        jsonResponse(res, 401, {
-            error: 'Missing or invalid API Key. Use header: Authorization: Bearer <your-api-key>',
-        });
+        const [status, body] = buildHttpError(ErrorCodes.PERMISSION_DENIED, 'Missing or invalid API Key', { suggestion: 'Use header: Authorization: Bearer <your-api-key>' });
+        // Auth failures are better represented as 401 even if the CEP code is permission-related.
+        jsonResponse(res, 401, body, protocolVersion);
         return;
     }
     // Parse request body
@@ -124,52 +197,220 @@ async function handleRun(req, res, searchPaths) {
         const body = await parseBody(req);
         request = JSON.parse(body);
     }
-    catch {
-        jsonResponse(res, 400, { error: 'Invalid JSON body' });
+    catch (e) {
+        const err = e;
+        if (err?.code === 'PAYLOAD_TOO_LARGE') {
+            const [status, body] = buildHttpError(ErrorCodes.INPUT_TOO_LARGE, 'Payload too large', { suggestion: 'Reduce input size to under 1MB' });
+            jsonResponse(res, status, body, protocolVersion);
+            return;
+        }
+        const [status, body] = buildHttpError(ErrorCodes.PARSE_ERROR, 'Invalid JSON body', { suggestion: 'Ensure request body is valid JSON' });
+        jsonResponse(res, status, body, protocolVersion);
+        return;
+    }
+    if (!request || typeof request !== 'object') {
+        const [status, body] = buildHttpError(ErrorCodes.INVALID_INPUT, 'Invalid request body', { suggestion: 'Ensure request body is a JSON object' });
+        jsonResponse(res, status, body, protocolVersion);
+        return;
+    }
+    const reqBody = request;
+    // Determine protocol version (body > header > query > default)
+    protocolVersion = getRequestedVersion(req, url, reqBody.version);
+    // If the client explicitly requested an unsupported version, return a structured error.
+    const requested = reqBody.version ?? req.headers['x-cognitive-version'] ?? url.searchParams.get('version') ?? undefined;
+    if (requested && !SUPPORTED_VERSIONS.includes(requested)) {
+        const [status, body] = buildHttpError(ErrorCodes.UNSUPPORTED_VALUE, `Unsupported protocol version: ${requested}`, { suggestion: `Use version=${DEFAULT_VERSION}` });
+        jsonResponse(res, status, body, protocolVersion);
         return;
     }
     // Validate request
-    if (!request.module || !request.args) {
-        jsonResponse(res, 400, { error: 'Missing required fields: module, args' });
+    if (!reqBody.module || !reqBody.args) {
+        const [status, body] = buildHttpError(ErrorCodes.MISSING_REQUIRED_FIELD, 'Missing required fields: module, args', {
+            moduleName: reqBody?.module ?? 'unknown',
+            suggestion: 'Provide both "module" and "args" fields in request body'
+        });
+        jsonResponse(res, status, body, protocolVersion);
         return;
     }
     // Find module
-    const moduleData = await findModule(request.module, searchPaths);
+    const moduleData = await findModule(reqBody.module, searchPaths);
     if (!moduleData) {
-        jsonResponse(res, 404, { error: `Module '${request.module}' not found` });
+        const [status, body] = buildHttpError(ErrorCodes.MODULE_NOT_FOUND, `Module '${reqBody.module}' not found`, {
+            moduleName: reqBody.module,
+            suggestion: 'Use GET /modules to list available modules'
+        });
+        jsonResponse(res, status, body, protocolVersion);
         return;
     }
     try {
         // Create provider
-        const provider = getProvider(request.provider, request.model);
-        // Run module
+        const provider = getProvider(reqBody.provider, reqBody.model);
+        const providerName = provider.name;
+        // Run module (always use v2.2 format internally)
         const result = await runModule(moduleData, provider, {
-            input: { query: request.args, code: request.args },
+            args: reqBody.args,
             useV22: true,
         });
-        const response = {
-            ok: result.ok,
-            module: request.module,
-            provider: request.provider || process.env.LLM_PROVIDER || 'openai',
-        };
-        if (result.ok) {
-            if ('meta' in result)
-                response.meta = result.meta;
-            if ('data' in result)
-                response.data = result.data;
-        }
-        else {
-            if ('error' in result)
-                response.error = result.error?.message;
+        // Attach transport context but do not rebuild the envelope.
+        const contextual = attachContext(result, {
+            module: reqBody.module,
+            provider: providerName,
+        });
+        if (contextual.ok) {
+            jsonResponse(res, 200, contextual, protocolVersion);
+            return;
         }
-        jsonResponse(res, 200, response);
+        const errorCode = (contextual.error?.code ?? ErrorCodes.INTERNAL_ERROR);
+        const status = httpStatusForErrorCode(errorCode);
+        jsonResponse(res, status, contextual, protocolVersion);
     }
     catch (error) {
-        jsonResponse(res, 500, {
-            ok: false,
-            error: error instanceof Error ? error.message : String(error),
-            module: request.module,
+        // Infrastructure error - still return envelope
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const [status, response] = buildHttpError(ErrorCodes.INTERNAL_ERROR, errorMessage, {
+            moduleName: reqBody?.module,
+            providerName: reqBody?.provider,
+            recoverable: false,
+        });
+        jsonResponse(res, status, response, protocolVersion);
+    }
+}
+async function handleRunStream(req, res, searchPaths, url) {
+    let protocolVersion = DEFAULT_VERSION;
+    let sseStarted = false;
+    const beginSse = (version) => {
+        if (sseStarted)
+            return;
+        sseStarted = true;
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream; charset=utf-8',
+            'Cache-Control': 'no-cache, no-transform',
+            'Connection': 'keep-alive',
+            'X-Accel-Buffering': 'no',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Cognitive-Version',
+            'Access-Control-Expose-Headers': 'X-Cognitive-Version',
+            'X-Cognitive-Version': version,
         });
+    };
+    const writeEvent = (ev, id) => {
+        const type = typeof ev.type === 'string' ? ev.type : 'message';
+        res.write(encodeSseFrame(ev, { event: type, id }));
+    };
+    // Helper: send an error as CEP events (start + error + end).
+    const sendErrorStream = (envelope) => {
+        beginSse(protocolVersion);
+        let id = 1;
+        writeEvent({ type: 'start', version: protocolVersion, timestamp_ms: 0, module: envelope.module ?? 'unknown' }, id++);
+        const err = envelope.error ?? { code: ErrorCodes.INTERNAL_ERROR, message: 'Unknown error' };
+        writeEvent({ type: 'error', version: protocolVersion, timestamp_ms: 0, module: envelope.module ?? 'unknown', provider: envelope.provider, error: err }, id++);
+        writeEvent({ type: 'end', version: protocolVersion, timestamp_ms: 0, module: envelope.module ?? 'unknown', provider: envelope.provider, result: envelope }, id++);
+        res.end();
+    };
+    // Verify API key
+    if (!verifyApiKey(req)) {
+        // Auth failures should still be structured; SSE payload carries the error.
+        const envelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.PERMISSION_DENIED,
+            message: 'Missing or invalid API Key',
+            suggestion: 'Use header: Authorization: Bearer <your-api-key>',
+            version: protocolVersion,
+        }), { module: 'unknown', provider: 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    // Parse request body
+    let request;
+    try {
+        const body = await parseBody(req);
+        request = JSON.parse(body);
+    }
+    catch (e) {
+        const err = e;
+        const code = err?.code === 'PAYLOAD_TOO_LARGE' ? ErrorCodes.INPUT_TOO_LARGE : ErrorCodes.PARSE_ERROR;
+        const message = err?.code === 'PAYLOAD_TOO_LARGE' ? 'Payload too large' : 'Invalid JSON body';
+        const envelope = attachContext(makeErrorEnvelope({
+            code,
+            message,
+            suggestion: code === ErrorCodes.INPUT_TOO_LARGE ? 'Reduce input size to under 1MB' : 'Ensure request body is valid JSON',
+            version: protocolVersion,
+        }), { module: 'unknown', provider: 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    if (!request || typeof request !== 'object') {
+        const envelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.INVALID_INPUT,
+            message: 'Invalid request body',
+            suggestion: 'Ensure request body is a JSON object',
+            version: protocolVersion,
+        }), { module: 'unknown', provider: 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    const reqBody = request;
+    protocolVersion = getRequestedVersion(req, url, reqBody.version);
+    // If the client explicitly requested an unsupported version, return a structured error.
+    const requested = reqBody.version ?? req.headers['x-cognitive-version'] ?? url.searchParams.get('version') ?? undefined;
+    if (requested && !SUPPORTED_VERSIONS.includes(requested)) {
+        const envelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.UNSUPPORTED_VALUE,
+            message: `Unsupported protocol version: ${requested}`,
+            suggestion: `Use version=${DEFAULT_VERSION}`,
+            version: protocolVersion,
+        }), { module: reqBody?.module ?? 'unknown', provider: reqBody?.provider ?? 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    // Validate request
+    if (!reqBody.module || !reqBody.args) {
+        const envelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.MISSING_REQUIRED_FIELD,
+            message: 'Missing required fields: module, args',
+            suggestion: 'Provide both "module" and "args" fields in request body',
+            version: protocolVersion,
+        }), { module: reqBody?.module ?? 'unknown', provider: reqBody?.provider ?? 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    // Find module
+    const moduleData = await findModule(reqBody.module, searchPaths);
+    if (!moduleData) {
+        const envelope = attachContext(makeErrorEnvelope({
+            code: ErrorCodes.MODULE_NOT_FOUND,
+            message: `Module '${reqBody.module}' not found`,
+            suggestion: 'Use GET /modules to list available modules',
+            version: protocolVersion,
+        }), { module: reqBody.module, provider: reqBody.provider ?? 'unknown' });
+        sendErrorStream(envelope);
+        return;
+    }
+    // Create provider
+    const provider = getProvider(reqBody.provider, reqBody.model);
+    const providerName = provider.name;
+    // Stream events
+    beginSse(protocolVersion);
+    let id = 1;
+    let closed = false;
+    const onClose = () => { closed = true; };
+    req.on('close', onClose);
+    res.on('close', onClose);
+    for await (const ev of runModuleStream(moduleData, provider, {
+        args: reqBody.args,
+        useV22: true,
+    })) {
+        if (closed)
+            break;
+        const contextualEv = {
+            ...ev,
+            module: reqBody.module,
+            provider: providerName,
+        };
+        writeEvent(contextualEv, id++);
+    }
+    if (!closed) {
+        res.end();
     }
 }
 export function createServer(options = {}) {
@@ -184,7 +425,8 @@ export function createServer(options = {}) {
             res.writeHead(204, {
                 'Access-Control-Allow-Origin': '*',
                 'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Cognitive-Version',
+                'Access-Control-Expose-Headers': 'X-Cognitive-Version',
             });
             res.end();
             return;
@@ -205,17 +447,30 @@ export function createServer(options = {}) {
                 await handleModuleInfo(res, moduleName, searchPaths);
             }
             else if (path === '/run' && method === 'POST') {
-                await handleRun(req, res, searchPaths);
+                await handleRun(req, res, searchPaths, url);
+            }
+            else if (path === '/run/stream' && method === 'POST') {
+                await handleRunStream(req, res, searchPaths, url);
             }
             else {
-                jsonResponse(res, 404, { error: 'Not found' });
+                const envelope = makeErrorEnvelope({
+                    code: ErrorCodes.ENDPOINT_NOT_FOUND,
+                    message: `Endpoint '${path}' not found`,
+                    suggestion: 'Use GET / to see available endpoints',
+                    risk: 'low',
+                });
+                jsonResponse(res, 404, envelope);
             }
         }
         catch (error) {
             console.error('Server error:', error);
-            jsonResponse(res, 500, {
-                error: error instanceof Error ? error.message : 'Internal server error',
+            const errorMessage = error instanceof Error ? error.message : 'Internal server error';
+            const envelope = makeErrorEnvelope({
+                code: ErrorCodes.INTERNAL_ERROR,
+                message: errorMessage,
+                recoverable: false,
             });
+            jsonResponse(res, 500, envelope);
         }
     });
     return server;
@@ -233,6 +488,7 @@ export async function serve(options = {}) {
             console.log('  GET  /modules   - List modules');
             console.log('  GET  /modules/:name - Module info');
             console.log('  POST /run       - Run module');
+            console.log('  POST /run/stream - Run module (SSE stream)');
             resolve();
         });
     });

package/dist/server/index.d.ts

@@ -3,3 +3,5 @@
  */
 export { serve, createServer } from './http.js';
 export type { ServeOptions } from './http.js';
+export { encodeSseFrame } from './sse.js';
+export type { SseFrameOptions } from './sse.js';

package/dist/server/index.js

@@ -2,3 +2,4 @@
  * Server - Re-export all server functionality
  */
 export { serve, createServer } from './http.js';
+export { encodeSseFrame } from './sse.js';

package/dist/server/sse.d.ts

@@ -0,0 +1,13 @@
+export interface SseFrameOptions {
+    event?: string;
+    id?: string | number;
+    retryMs?: number;
+}
+/**
+ * Encode a payload into an SSE frame.
+ *
+ * Notes:
+ * - SSE requires each data line to be prefixed with `data:`.
+ * - `event:` maps cleanly to CEP `type` to keep transport mapping deterministic.
+ */
+export declare function encodeSseFrame(data: unknown, options?: SseFrameOptions): string;

package/dist/server/sse.js

@@ -0,0 +1,22 @@
+/**
+ * Encode a payload into an SSE frame.
+ *
+ * Notes:
+ * - SSE requires each data line to be prefixed with `data:`.
+ * - `event:` maps cleanly to CEP `type` to keep transport mapping deterministic.
+ */
+export function encodeSseFrame(data, options = {}) {
+    const lines = [];
+    if (options.retryMs !== undefined)
+        lines.push(`retry: ${options.retryMs}`);
+    if (options.id !== undefined)
+        lines.push(`id: ${options.id}`);
+    if (options.event)
+        lines.push(`event: ${options.event}`);
+    const json = JSON.stringify(data);
+    for (const line of json.split('\n')) {
+        lines.push(`data: ${line}`);
+    }
+    lines.push(''); // End of event
+    return lines.join('\n') + '\n';
+}

package/dist/types.d.ts

@@ -6,6 +6,17 @@ export interface Provider {
     name: string;
     invoke(params: InvokeParams): Promise<InvokeResult>;
     isConfigured(): boolean;
+    /**
+     * Stream-based invoke (optional).
+     * Returns an async generator that yields content chunks.
+     *
+     * If not implemented, falls back to non-streaming invoke.
+     */
+    invokeStream?(params: InvokeParams): AsyncGenerator<string, InvokeResult, unknown>;
+    /**
+     * Check if this provider supports streaming.
+     */
+    supportsStreaming?(): boolean;
 }
 export interface InvokeParams {
     messages: Message[];
@@ -222,14 +233,19 @@ export interface EnvelopeMeta {
 }
 /**
  * Enhanced error structure with retry and recovery info (v2.2.1).
+ *
+ * Consistent across HTTP, MCP, and CLI layers.
+ * See ERROR-CODES.md for error code taxonomy.
  */
 export interface EnvelopeError {
-    /** Error code (e.g., "INVALID_INPUT", "PARSE_ERROR") */
+    /** Error code (E-format like "E4006" or legacy like "MODULE_NOT_FOUND") */
     code: string;
     /** Human-readable error message */
     message: string;
     /** Whether the error can be retried */
     recoverable?: boolean;
+    /** Suggested action to fix the error */
+    suggestion?: string;
     /** Suggested wait time before retry (in milliseconds) */
     retry_after_ms?: number;
     /** Additional error context */
@@ -337,11 +353,26 @@ export interface CommandContext {
     provider: Provider;
     verbose?: boolean;
 }
+/**
+ * CLI command result (legacy format).
+ *
+ * For new code, prefer using CognitiveErrorEnvelope from errors/index.js
+ * for error responses to ensure cross-layer consistency.
+ */
 export interface CommandResult {
     success: boolean;
     data?: unknown;
     error?: string;
 }
+/**
+ * Extended command result with unified error structure.
+ * Use this for commands that need full error details.
+ */
+export interface CommandResultV2 {
+    ok: boolean;
+    data?: unknown;
+    error?: EnvelopeError;
+}
 export interface ModuleInput {
     code?: string;
     query?: string;

package/dist/types.js

@@ -44,7 +44,10 @@ function aggregateRiskFromList(items) {
     }
     let maxLevel = 0;
     for (const item of items) {
-        const level = riskLevels[item.risk ?? 'medium'];
+        const riskKey = item.risk;
+        const level = typeof riskKey === 'string' && Object.prototype.hasOwnProperty.call(riskLevels, riskKey)
+            ? riskLevels[riskKey]
+            : riskLevels.medium;
         maxLevel = Math.max(maxLevel, level);
     }
     return riskNames[maxLevel];

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,4 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const VERSION = pkg.version ?? '0.0.0';

package/package.json

@@ -1,18 +1,32 @@
 {
   "name": "cognitive-modules-cli",
-  "version": "2.2.1",
+  "version": "2.2.7",
   "description": "Cognitive Modules - Structured AI Task Execution with version management",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "cognitive-modules-cli": "dist/cli.js",
     "cog": "dist/cli.js"
   },
   "scripts": {
-    "build": "tsc",
+    "clean": "node -e \"import('node:fs').then(fs=>fs.rmSync('dist',{recursive:true,force:true}))\"",
+    "build": "npm run clean && tsc",
     "start": "node dist/cli.js",
     "dev": "tsx src/cli.ts",
-    "prepublishOnly": "npm run build"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "pack:check": "npm pack --dry-run --json --cache ../../.npm-cache",
+    "release:check": "npm run build && npm test && npm run pack:check",
+    "prepublishOnly": "npm run release:check"
   },
   "keywords": [
     "cognitive",
@@ -25,13 +39,22 @@
   ],
   "license": "MIT",
   "author": "ziel-io",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/ziel-io/cognitive-modules.git"
+    "url": "https://github.com/Cognary/cognitive.git"
   },
-  "homepage": "https://ziel-io.github.io/cognitive-modules/",
+  "homepage": "https://cognary.github.io/cognitive/",
   "bugs": {
-    "url": "https://github.com/ziel-io/cognitive-modules/issues"
+    "url": "https://github.com/Cognary/cognitive/issues"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -47,6 +70,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.0"
   }
 }

package/dist/modules/composition.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Tests for Composition Engine
- *
- * Tests all COMPOSITION.md specified functionality:
- * - JSONPath-like expression evaluation
- * - Condition expression evaluation
- * - Aggregation strategies
- * - Version matching
- * - Sequential, Parallel, Conditional, Iterative patterns
- */
-export {};