cognitive-modules-cli 2.2.0 → 2.2.5

package/dist/modules/subagent.d.ts

@@ -22,6 +22,7 @@ export interface CallDirective {
 }
 export interface SubagentRunOptions {
     input?: ModuleInput;
+    args?: string;
     validateInput?: boolean;
     validateOutput?: boolean;
     maxDepth?: number;
@@ -45,7 +46,11 @@ export declare function parseCalls(text: string): CallDirective[];
 /**
  * Replace @call directives with their results
  */
-export declare function substituteCallResults(text: string, callResults: Record<string, unknown>): string;
+export declare function substituteCallResults(text: string, callResults: Array<{
+    match: string;
+    module: string;
+    result: unknown;
+}>): string;
 export declare class SubagentOrchestrator {
     private provider;
     private running;

package/dist/modules/subagent.js

@@ -75,11 +75,15 @@ export function parseCalls(text) {
  */
 export function substituteCallResults(text, callResults) {
     let result = text;
-    for (const [callStr, callResult] of Object.entries(callResults)) {
-        const resultStr = typeof callResult === 'object'
-            ? JSON.stringify(callResult, null, 2)
-            : String(callResult);
-        result = result.replace(callStr, `[Result from ${callStr}]:\n${resultStr}`);
+    for (const entry of callResults) {
+        const resultStr = typeof entry.result === 'object'
+            ? JSON.stringify(entry.result, null, 2)
+            : String(entry.result);
+        const replacement = `[Result from ${entry.module}]:\n${resultStr}`;
+        const idx = result.indexOf(entry.match);
+        if (idx !== -1) {
+            result = result.slice(0, idx) + replacement + result.slice(idx + entry.match.length);
+        }
     }
     return result;
 }
@@ -99,7 +103,7 @@ export class SubagentOrchestrator {
      * Recursively resolves @call directives before final execution.
      */
     async run(moduleName, options = {}, context) {
-        const { input = {}, validateInput = true, validateOutput = true, maxDepth = 5 } = options;
+        const { input = {}, args, validateInput = true, validateOutput = true, maxDepth = 5 } = options;
         // Initialize context
         const ctx = context ?? createContext(maxDepth);
         // Check depth limit
@@ -122,15 +126,14 @@ export class SubagentOrchestrator {
             const moduleContextMode = module.context ?? 'main';
             // Parse @call directives from prompt
             const calls = parseCalls(module.prompt);
-            const callResults = {};
+            const callResults = [];
             // Resolve each @call directive
             for (const call of calls) {
                 const childModule = call.module;
                 const childArgs = call.args;
                 // Prepare child input
-                const childInput = childArgs
-                    ? { query: childArgs, code: childArgs }
-                    : { ...input };
+                const hasChildArgs = childArgs.length > 0;
+                const childInput = hasChildArgs ? {} : { ...input };
                 // Determine child context
                 const childContext = moduleContextMode === 'fork'
                     ? forkContext(ctx, moduleName)
@@ -138,20 +141,21 @@ export class SubagentOrchestrator {
                 // Recursively run child module
                 const childResult = await this.run(childModule, {
                     input: childInput,
+                    args: hasChildArgs ? childArgs : undefined,
                     validateInput: false, // Skip validation for @call args
                     validateOutput
                 }, childContext);
                 // Store result
                 if (childResult.ok && 'data' in childResult) {
-                    callResults[call.match] = childResult.data;
+                    callResults.push({ match: call.match, module: call.module, result: childResult.data });
                 }
                 else if ('error' in childResult) {
-                    callResults[call.match] = { error: childResult.error };
+                    callResults.push({ match: call.match, module: call.module, result: { error: childResult.error } });
                 }
             }
             // Substitute call results into prompt
             let modifiedModule = module;
-            if (Object.keys(callResults).length > 0) {
+            if (callResults.length > 0) {
                 const modifiedPrompt = substituteCallResults(module.prompt, callResults);
                 modifiedModule = {
                     ...module,
@@ -161,6 +165,9 @@ export class SubagentOrchestrator {
             // Run the module
             const result = await runModule(modifiedModule, this.provider, {
                 input,
+                args,
+                validateInput,
+                validateOutput,
                 verbose: false,
                 useV22: true
             });

package/dist/modules/validator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Module Validator - Validate cognitive module structure and examples.
+ * Supports v0, v1, v2.1, and v2.2 module formats.
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validate a cognitive module's structure and examples.
+ * Supports all formats.
+ *
+ * @param nameOrPath Module name or path
+ * @param v22 If true, validate v2.2 specific requirements
+ * @returns Validation result with errors and warnings
+ */
+export declare function validateModule(modulePath: string, v22?: boolean): Promise<ValidationResult>;
+/**
+ * Validate a response against v2.2 envelope format.
+ *
+ * @param response The response dict to validate
+ * @returns Validation result
+ */
+export declare function validateV22Envelope(response: Record<string, unknown>): {
+    valid: boolean;
+    errors: string[];
+};