coaian 0.7.0

package/dist/validation.d.ts

@@ -0,0 +1,28 @@
+type ValidationType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'enum';
+interface ValidationRule {
+    type: ValidationType;
+    required?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    minValue?: number;
+    maxValue?: number;
+    enumValues?: (string | number)[];
+    items?: ValidationRule;
+    properties?: Record<string, ValidationRule>;
+}
+interface ValidationSchema {
+    [key: string]: ValidationRule;
+}
+export declare function validate(args: any, schema: ValidationSchema): {
+    valid: boolean;
+    error?: string;
+};
+export declare const ValidationSchemas: {
+    stringArray: (minLength?: number) => ValidationRule;
+    entityArray: () => ValidationRule;
+    relationArray: () => ValidationRule;
+    isoDate: () => ValidationRule;
+    nonEmptyString: () => ValidationRule;
+};
+export {};

package/dist/validation.js

@@ -0,0 +1,145 @@
+export function validate(args, schema) {
+    if (typeof args !== 'object' || args === null) {
+        return { valid: false, error: 'Arguments must be an object' };
+    }
+    for (const [key, rule] of Object.entries(schema)) {
+        const value = args[key];
+        // Check required
+        if (rule.required && (value === undefined || value === null)) {
+            return { valid: false, error: `Missing required field: ${key}` };
+        }
+        if (value === undefined || value === null)
+            continue;
+        // Type validation
+        const result = validateValue(value, rule, key);
+        if (!result.valid)
+            return result;
+    }
+    return { valid: true };
+}
+function validateValue(value, rule, path) {
+    // Type check
+    switch (rule.type) {
+        case 'string':
+            if (typeof value !== 'string') {
+                return { valid: false, error: `${path} must be a string, got ${typeof value}` };
+            }
+            if (rule.minLength && value.length < rule.minLength) {
+                return { valid: false, error: `${path} must be at least ${rule.minLength} characters` };
+            }
+            if (rule.maxLength && value.length > rule.maxLength) {
+                return { valid: false, error: `${path} must be at most ${rule.maxLength} characters` };
+            }
+            if (rule.pattern && !rule.pattern.test(value)) {
+                return { valid: false, error: `${path} format is invalid` };
+            }
+            if (rule.enumValues && !rule.enumValues.includes(value)) {
+                return { valid: false, error: `${path} must be one of: ${rule.enumValues.join(', ')}` };
+            }
+            break;
+        case 'number':
+            if (typeof value !== 'number' || isNaN(value)) {
+                return { valid: false, error: `${path} must be a number` };
+            }
+            if (rule.minValue !== undefined && value < rule.minValue) {
+                return { valid: false, error: `${path} must be at least ${rule.minValue}` };
+            }
+            if (rule.maxValue !== undefined && value > rule.maxValue) {
+                return { valid: false, error: `${path} must be at most ${rule.maxValue}` };
+            }
+            if (rule.enumValues && !rule.enumValues.includes(value)) {
+                return { valid: false, error: `${path} must be one of: ${rule.enumValues.join(', ')}` };
+            }
+            break;
+        case 'boolean':
+            if (typeof value !== 'boolean') {
+                return { valid: false, error: `${path} must be a boolean` };
+            }
+            break;
+        case 'date':
+            if (typeof value !== 'string') {
+                return { valid: false, error: `${path} must be an ISO date string` };
+            }
+            if (isNaN(Date.parse(value))) {
+                return { valid: false, error: `${path} must be a valid ISO date string` };
+            }
+            break;
+        case 'array':
+            if (!Array.isArray(value)) {
+                return { valid: false, error: `${path} must be an array` };
+            }
+            if (rule.minLength && value.length < rule.minLength) {
+                return { valid: false, error: `${path} must have at least ${rule.minLength} items` };
+            }
+            if (rule.maxLength && value.length > rule.maxLength) {
+                return { valid: false, error: `${path} must have at most ${rule.maxLength} items` };
+            }
+            if (rule.items) {
+                for (let i = 0; i < value.length; i++) {
+                    const itemResult = validateValue(value[i], rule.items, `${path}[${i}]`);
+                    if (!itemResult.valid)
+                        return itemResult;
+                }
+            }
+            break;
+        case 'object':
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                return { valid: false, error: `${path} must be an object` };
+            }
+            if (rule.properties) {
+                const nestedResult = validate(value, rule.properties);
+                if (!nestedResult.valid) {
+                    return { valid: false, error: `${path}: ${nestedResult.error}` };
+                }
+            }
+            break;
+        case 'enum':
+            if (!rule.enumValues?.includes(value)) {
+                return { valid: false, error: `${path} must be one of: ${rule.enumValues?.join(', ')}` };
+            }
+            break;
+    }
+    return { valid: true };
+}
+// Pre-built schemas for common tool patterns
+export const ValidationSchemas = {
+    stringArray: (minLength = 0) => ({
+        type: 'array',
+        required: true,
+        minLength,
+        items: { type: 'string' }
+    }),
+    entityArray: () => ({
+        type: 'array',
+        required: true,
+        items: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', required: true },
+                entityType: { type: 'string', required: true },
+                observations: { type: 'array', required: true, items: { type: 'string' } }
+            }
+        }
+    }),
+    relationArray: () => ({
+        type: 'array',
+        required: true,
+        items: {
+            type: 'object',
+            properties: {
+                from: { type: 'string', required: true },
+                to: { type: 'string', required: true },
+                relationType: { type: 'string', required: true }
+            }
+        }
+    }),
+    isoDate: () => ({
+        type: 'date',
+        required: true
+    }),
+    nonEmptyString: () => ({
+        type: 'string',
+        required: true,
+        minLength: 1
+    })
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "coaian",
+  "version": "0.7.0",
+  "description": "Creative Orientation AI Agentic Memories - Narrative Beat Extension with IAIP relational integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "coaia-narrative": "dist/index.js",
+    "cnarrative": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node test-coaia-narrative.js",
+    "lint": "eslint index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "coaia",
+    "narrative",
+    "structural-tension-chart",
+    "mcp",
+    "memory",
+    "iaip",
+    "four-directions",
+    "relational"
+  ],
+  "author": "avadisabelle",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "minimist": "^1.2.8",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "coaia-memory": "^2.3.1"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE",
+    "DESIGN.md",
+    "IMPLEMENTATION_ROADMAP.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/avadisabelle/coaia-narrative"
+  }
+}