cognitive-modules-cli 2.2.1 → 2.2.7

package/src/commands/add.ts

@@ -1,315 +0,0 @@
-/**
- * Add command - Install modules from GitHub
- * 
- * cog add ziel-io/cognitive-modules -m code-simplifier
- * cog add https://github.com/org/repo --module name --tag v1.0.0
- */
-
-import { createWriteStream, existsSync, mkdirSync, rmSync, readdirSync, statSync, copyFileSync } from 'node:fs';
-import { writeFile, readFile, mkdir, rm } from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
-import { Readable } from 'node:stream';
-import { join, basename } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-import { createGunzip } from 'node:zlib';
-import type { CommandContext, CommandResult } from '../types.js';
-
-// Module storage paths
-const USER_MODULES_DIR = join(homedir(), '.cognitive', 'modules');
-const INSTALLED_MANIFEST = join(homedir(), '.cognitive', 'installed.json');
-
-export interface AddOptions {
-  module?: string;
-  name?: string;
-  branch?: string;
-  tag?: string;
-}
-
-interface InstallManifest {
-  [moduleName: string]: {
-    source: string;
-    githubUrl: string;
-    modulePath?: string;
-    tag?: string;
-    branch?: string;
-    version?: string;
-    installedAt: string;
-    installedTime: string;
-  };
-}
-
-/**
- * Parse GitHub URL or shorthand
- */
-function parseGitHubUrl(url: string): { org: string; repo: string; fullUrl: string } {
-  // Handle shorthand: org/repo
-  if (!url.startsWith('http')) {
-    url = `https://github.com/${url}`;
-  }
-  
-  const match = url.match(/https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/?/);
-  if (!match) {
-    throw new Error(`Invalid GitHub URL: ${url}`);
-  }
-  
-  const org = match[1];
-  const repo = match[2].replace(/\.git$/, '');
-  
-  return {
-    org,
-    repo,
-    fullUrl: `https://github.com/${org}/${repo}`,
-  };
-}
-
-/**
- * Download and extract ZIP from GitHub
- */
-async function downloadAndExtract(
-  org: string,
-  repo: string,
-  ref: string,
-  isTag: boolean
-): Promise<string> {
-  const zipUrl = isTag
-    ? `https://github.com/${org}/${repo}/archive/refs/tags/${ref}.zip`
-    : `https://github.com/${org}/${repo}/archive/refs/heads/${ref}.zip`;
-  
-  // Create temp directory
-  const tempDir = join(tmpdir(), `cog-${Date.now()}`);
-  mkdirSync(tempDir, { recursive: true });
-  
-  const zipPath = join(tempDir, 'repo.zip');
-  
-  // Download ZIP
-  const response = await fetch(zipUrl, {
-    headers: { 'User-Agent': 'cognitive-runtime/1.0' },
-  });
-  
-  if (!response.ok) {
-    throw new Error(`Failed to download: ${response.status} ${response.statusText}`);
-  }
-  
-  // Save to file
-  const fileStream = createWriteStream(zipPath);
-  await pipeline(Readable.fromWeb(response.body as any), fileStream);
-  
-  // Extract using built-in unzip (available on most systems)
-  const { execSync } = await import('node:child_process');
-  execSync(`unzip -q "${zipPath}" -d "${tempDir}"`, { stdio: 'pipe' });
-  
-  // Find extracted directory
-  const entries = readdirSync(tempDir).filter(
-    e => e !== 'repo.zip' && statSync(join(tempDir, e)).isDirectory()
-  );
-  
-  if (entries.length === 0) {
-    throw new Error('ZIP file was empty');
-  }
-  
-  return join(tempDir, entries[0]);
-}
-
-/**
- * Check if a directory is a valid module
- */
-function isValidModule(path: string): boolean {
-  return (
-    existsSync(join(path, 'module.yaml')) ||
-    existsSync(join(path, 'MODULE.md')) ||
-    existsSync(join(path, 'module.md'))
-  );
-}
-
-/**
- * Find module within repository
- */
-function findModuleInRepo(repoRoot: string, modulePath: string): string {
-  const possiblePaths = [
-    join(repoRoot, modulePath),
-    join(repoRoot, 'cognitive', 'modules', modulePath),
-    join(repoRoot, 'modules', modulePath),
-  ];
-  
-  for (const p of possiblePaths) {
-    if (existsSync(p) && isValidModule(p)) {
-      return p;
-    }
-  }
-  
-  throw new Error(
-    `Module not found at: ${modulePath}\n` +
-    `Searched in: ${possiblePaths.map(p => p.replace(repoRoot, '.')).join(', ')}`
-  );
-}
-
-/**
- * Copy directory recursively
- */
-function copyDir(src: string, dest: string): void {
-  mkdirSync(dest, { recursive: true });
-  
-  for (const entry of readdirSync(src)) {
-    const srcPath = join(src, entry);
-    const destPath = join(dest, entry);
-    
-    if (statSync(srcPath).isDirectory()) {
-      copyDir(srcPath, destPath);
-    } else {
-      copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
-/**
- * Get module version from module.yaml or MODULE.md
- */
-async function getModuleVersion(modulePath: string): Promise<string | undefined> {
-  const yaml = await import('js-yaml');
-  
-  // Try v2 format
-  const yamlPath = join(modulePath, 'module.yaml');
-  if (existsSync(yamlPath)) {
-    const content = await readFile(yamlPath, 'utf-8');
-    const data = yaml.load(content) as { version?: string };
-    return data?.version;
-  }
-  
-  // Try v1 format
-  const mdPath = existsSync(join(modulePath, 'MODULE.md'))
-    ? join(modulePath, 'MODULE.md')
-    : join(modulePath, 'module.md');
-  
-  if (existsSync(mdPath)) {
-    const content = await readFile(mdPath, 'utf-8');
-    if (content.startsWith('---')) {
-      const parts = content.split('---');
-      if (parts.length >= 3) {
-        const meta = yaml.load(parts[1]) as { version?: string };
-        return meta?.version;
-      }
-    }
-  }
-  
-  return undefined;
-}
-
-/**
- * Record installation info
- */
-async function recordInstall(
-  moduleName: string,
-  info: InstallManifest[string]
-): Promise<void> {
-  let manifest: InstallManifest = {};
-  
-  if (existsSync(INSTALLED_MANIFEST)) {
-    const content = await readFile(INSTALLED_MANIFEST, 'utf-8');
-    manifest = JSON.parse(content);
-  }
-  
-  manifest[moduleName] = info;
-  
-  await mkdir(join(homedir(), '.cognitive'), { recursive: true });
-  await writeFile(INSTALLED_MANIFEST, JSON.stringify(manifest, null, 2));
-}
-
-/**
- * Get installation info for a module
- */
-export async function getInstallInfo(moduleName: string): Promise<InstallManifest[string] | null> {
-  if (!existsSync(INSTALLED_MANIFEST)) {
-    return null;
-  }
-  
-  const content = await readFile(INSTALLED_MANIFEST, 'utf-8');
-  const manifest: InstallManifest = JSON.parse(content);
-  return manifest[moduleName] || null;
-}
-
-/**
- * Add a module from GitHub
- */
-export async function add(
-  url: string,
-  ctx: CommandContext,
-  options: AddOptions = {}
-): Promise<CommandResult> {
-  const { org, repo, fullUrl } = parseGitHubUrl(url);
-  const { module: modulePath, name, branch = 'main', tag } = options;
-  
-  // Determine ref (tag takes priority)
-  const ref = tag || branch;
-  const isTag = !!tag;
-  
-  let repoRoot: string;
-  let sourcePath: string;
-  let moduleName: string;
-  
-  try {
-    // Download repository
-    repoRoot = await downloadAndExtract(org, repo, ref, isTag);
-    
-    // Find module
-    if (modulePath) {
-      sourcePath = findModuleInRepo(repoRoot, modulePath);
-    } else {
-      // Use repo root as module
-      if (!isValidModule(repoRoot)) {
-        throw new Error(
-          'Repository root is not a valid module. Use --module to specify the module path.'
-        );
-      }
-      sourcePath = repoRoot;
-    }
-    
-    // Determine module name
-    moduleName = name || basename(sourcePath);
-    
-    // Get version
-    const version = await getModuleVersion(sourcePath);
-    
-    // Install to user modules dir
-    const targetPath = join(USER_MODULES_DIR, moduleName);
-    
-    // Remove existing
-    if (existsSync(targetPath)) {
-      rmSync(targetPath, { recursive: true, force: true });
-    }
-    
-    // Copy module
-    await mkdir(USER_MODULES_DIR, { recursive: true });
-    copyDir(sourcePath, targetPath);
-    
-    // Record installation info
-    await recordInstall(moduleName, {
-      source: sourcePath,
-      githubUrl: fullUrl,
-      modulePath,
-      tag,
-      branch,
-      version,
-      installedAt: targetPath,
-      installedTime: new Date().toISOString(),
-    });
-    
-    // Cleanup temp directory
-    const tempDir = repoRoot.split('/').slice(0, -1).join('/');
-    rmSync(tempDir, { recursive: true, force: true });
-    
-    return {
-      success: true,
-      data: {
-        message: `Added: ${moduleName}${version ? ` v${version}` : ''}`,
-        name: moduleName,
-        version,
-        location: targetPath,
-      },
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error),
-    };
-  }
-}

package/src/commands/compose.ts

@@ -1,185 +0,0 @@
-/**
- * cog compose - Execute a Composed Cognitive Module Workflow
- * 
- * Supports all composition patterns:
- * - Sequential: A → B → C
- * - Parallel: A → [B, C, D] → Aggregate
- * - Conditional: A → (condition) → B or C
- * - Iterative: A → (check) → A → ... → Done
- */
-
-import type { CommandContext, CommandResult } from '../types.js';
-import { findModule, getDefaultSearchPaths, executeComposition } from '../modules/index.js';
-
-export interface ComposeOptions {
-  /** Direct text input */
-  args?: string;
-  /** JSON input data */
-  input?: string;
-  /** Maximum composition depth */
-  maxDepth?: number;
-  /** Timeout in milliseconds */
-  timeout?: number;
-  /** Include execution trace */
-  trace?: boolean;
-  /** Pretty print output */
-  pretty?: boolean;
-  /** Verbose mode */
-  verbose?: boolean;
-}
-
-export async function compose(
-  moduleName: string,
-  ctx: CommandContext,
-  options: ComposeOptions = {}
-): Promise<CommandResult> {
-  const searchPaths = getDefaultSearchPaths(ctx.cwd);
-  
-  // Find module
-  const module = await findModule(moduleName, searchPaths);
-  if (!module) {
-    return {
-      success: false,
-      error: `Module not found: ${moduleName}\nSearch paths: ${searchPaths.join(', ')}`,
-    };
-  }
-
-  try {
-    // Parse input if provided as JSON
-    let inputData: Record<string, unknown> = {};
-    if (options.input) {
-      try {
-        inputData = JSON.parse(options.input);
-      } catch {
-        return {
-          success: false,
-          error: `Invalid JSON input: ${options.input}`,
-        };
-      }
-    }
-    
-    // Handle --args as text input
-    if (options.args) {
-      inputData.query = options.args;
-      inputData.code = options.args;
-    }
-
-    // Execute composition
-    const result = await executeComposition(
-      moduleName,
-      inputData,
-      ctx.provider,
-      {
-        cwd: ctx.cwd,
-        maxDepth: options.maxDepth,
-        timeoutMs: options.timeout
-      }
-    );
-
-    if (options.verbose) {
-      console.error('--- Composition Trace ---');
-      for (const entry of result.trace) {
-        const status = entry.success 
-          ? (entry.skipped ? '⏭️ SKIPPED' : '✅ OK') 
-          : '❌ FAILED';
-        console.error(`${status} ${entry.module} (${entry.durationMs}ms)`);
-        if (entry.reason) {
-          console.error(`   Reason: ${entry.reason}`);
-        }
-      }
-      console.error(`--- Total: ${result.totalTimeMs}ms ---`);
-    }
-
-    // Return result
-    if (options.trace) {
-      // Include full result with trace
-      return {
-        success: result.ok,
-        data: {
-          ok: result.ok,
-          result: result.result,
-          moduleResults: result.moduleResults,
-          trace: result.trace,
-          totalTimeMs: result.totalTimeMs,
-          error: result.error
-        }
-      };
-    } else if (options.pretty) {
-      return {
-        success: result.ok,
-        data: result.result,
-      };
-    } else {
-      // For non-pretty mode, return data (success) or error (failure)
-      if (result.ok && result.result) {
-        return {
-          success: true,
-          data: (result.result as { data?: unknown }).data,
-        };
-      } else {
-        return {
-          success: false,
-          error: result.error 
-            ? `${result.error.code}: ${result.error.message}` 
-            : 'Composition failed',
-          data: result.moduleResults,
-        };
-      }
-    }
-  } catch (e) {
-    return {
-      success: false,
-      error: e instanceof Error ? e.message : String(e),
-    };
-  }
-}
-
-/**
- * Show composition info for a module
- */
-export async function composeInfo(
-  moduleName: string,
-  ctx: CommandContext
-): Promise<CommandResult> {
-  const searchPaths = getDefaultSearchPaths(ctx.cwd);
-  
-  const module = await findModule(moduleName, searchPaths);
-  if (!module) {
-    return {
-      success: false,
-      error: `Module not found: ${moduleName}`,
-    };
-  }
-
-  const composition = module.composition;
-  if (!composition) {
-    return {
-      success: true,
-      data: {
-        name: module.name,
-        hasComposition: false,
-        message: 'Module does not have composition configuration'
-      }
-    };
-  }
-
-  return {
-    success: true,
-    data: {
-      name: module.name,
-      hasComposition: true,
-      pattern: composition.pattern,
-      requires: composition.requires?.map(d => ({
-        name: d.name,
-        version: d.version,
-        optional: d.optional,
-        fallback: d.fallback
-      })),
-      dataflowSteps: composition.dataflow?.length ?? 0,
-      routingRules: composition.routing?.length ?? 0,
-      maxDepth: composition.max_depth,
-      timeoutMs: composition.timeout_ms,
-      iteration: composition.iteration
-    }
-  };
-}

package/src/commands/index.ts

@@ -1,13 +0,0 @@
-/**
- * Commands - Re-export all commands
- */
-
-export * from './run.js';
-export * from './list.js';
-export * from './pipe.js';
-export * from './init.js';
-export * from './add.js';
-export * from './update.js';
-export * from './remove.js';
-export * from './versions.js';
-export * from './compose.js';

package/src/commands/init.ts

@@ -1,94 +0,0 @@
-/**
- * cog init - Initialize a new Cognitive project
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import type { CommandContext, CommandResult } from '../types.js';
-
-const EXAMPLE_MODULE_MD = `---
-name: my-module
-version: 1.0.0
-responsibility: Describe what this module does
-excludes:
-  - Do not do X
-  - Do not do Y
----
-
-Analyze the following input and provide a structured response:
-
-$ARGUMENTS
-
-Return a JSON object with your analysis.
-`;
-
-const EXAMPLE_SCHEMA_JSON = `{
-  "type": "object",
-  "properties": {
-    "result": {
-      "type": "string",
-      "description": "The main result of the analysis"
-    },
-    "confidence": {
-      "type": "number",
-      "minimum": 0,
-      "maximum": 1,
-      "description": "Confidence score"
-    },
-    "rationale": {
-      "type": "string",
-      "description": "Explanation of the reasoning"
-    }
-  },
-  "required": ["result", "confidence", "rationale"]
-}
-`;
-
-export async function init(ctx: CommandContext, moduleName?: string): Promise<CommandResult> {
-  const cognitiveDir = path.join(ctx.cwd, 'cognitive', 'modules');
-  
-  try {
-    // Create directory structure
-    await fs.mkdir(cognitiveDir, { recursive: true });
-    
-    // If module name provided, create a new module
-    if (moduleName) {
-      const moduleDir = path.join(cognitiveDir, moduleName);
-      await fs.mkdir(moduleDir, { recursive: true });
-      
-      await fs.writeFile(
-        path.join(moduleDir, 'MODULE.md'),
-        EXAMPLE_MODULE_MD.replace('my-module', moduleName)
-      );
-      
-      await fs.writeFile(
-        path.join(moduleDir, 'schema.json'),
-        EXAMPLE_SCHEMA_JSON
-      );
-      
-      return {
-        success: true,
-        data: {
-          message: `Created module: ${moduleName}`,
-          location: moduleDir,
-          files: ['MODULE.md', 'schema.json'],
-        },
-      };
-    }
-    
-    // Just initialize the directory
-    return {
-      success: true,
-      data: {
-        message: 'Cognitive project initialized',
-        location: cognitiveDir,
-        hint: 'Run "cog init <module-name>" to create a new module',
-      },
-    };
-  } catch (e) {
-    return {
-      success: false,
-      error: e instanceof Error ? e.message : String(e),
-    };
-  }
-}

package/src/commands/list.ts

@@ -1,33 +0,0 @@
-/**
- * cog list - List available Cognitive Modules
- */
-
-import type { CommandContext, CommandResult } from '../types.js';
-import { listModules, getDefaultSearchPaths } from '../modules/index.js';
-
-export async function list(ctx: CommandContext): Promise<CommandResult> {
-  const searchPaths = getDefaultSearchPaths(ctx.cwd);
-  const modules = await listModules(searchPaths);
-
-  if (modules.length === 0) {
-    return {
-      success: true,
-      data: {
-        modules: [],
-        message: `No modules found in: ${searchPaths.join(', ')}`,
-      },
-    };
-  }
-
-  return {
-    success: true,
-    data: {
-      modules: modules.map(m => ({
-        name: m.name,
-        version: m.version,
-        responsibility: m.responsibility,
-        location: m.location,
-      })),
-    },
-  };
-}

package/src/commands/pipe.ts

@@ -1,76 +0,0 @@
-/**
- * cog pipe - Pipe mode for stdin/stdout integration
- */
-
-import * as readline from 'node:readline';
-import type { CommandContext, CommandResult } from '../types.js';
-import { findModule, getDefaultSearchPaths, runModule } from '../modules/index.js';
-
-export interface PipeOptions {
-  module: string;
-  noValidate?: boolean;
-}
-
-export async function pipe(
-  ctx: CommandContext,
-  options: PipeOptions
-): Promise<CommandResult> {
-  const searchPaths = getDefaultSearchPaths(ctx.cwd);
-  
-  // Find module
-  const module = await findModule(options.module, searchPaths);
-  if (!module) {
-    return {
-      success: false,
-      error: `Module not found: ${options.module}`,
-    };
-  }
-
-  // Read from stdin
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: false,
-  });
-
-  const lines: string[] = [];
-  for await (const line of rl) {
-    lines.push(line);
-  }
-  
-  const input = lines.join('\n');
-
-  try {
-    // Check if input is JSON
-    let inputData: Record<string, unknown> | undefined;
-    try {
-      inputData = JSON.parse(input);
-    } catch {
-      // Not JSON, use as args
-    }
-
-    const result = await runModule(module, ctx.provider, {
-      args: inputData ? undefined : input,
-      input: inputData,
-    });
-
-    // Output envelope format to stdout
-    console.log(JSON.stringify(result));
-
-    return {
-      success: result.ok,
-      data: result,
-    };
-  } catch (e) {
-    const error = e instanceof Error ? e.message : String(e);
-    // Output error in envelope format
-    console.log(JSON.stringify({
-      ok: false,
-      error: { code: 'RUNTIME_ERROR', message: error }
-    }));
-    return {
-      success: false,
-      error,
-    };
-  }
-}