cognitive-modules 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

cognitive/__init__.py

@@ -9,4 +9,4 @@ Usage:
     cog doctor                   # Check environment setup
 """
 
-__version__ = "0.1.0"
+__version__ = "0.5.0"

cognitive/cli.py

@@ -1,16 +1,22 @@
 """
-Cognitive CLI - Main entry point for the cog command.
+Cognitive CLI - Main entry point for the cogn command.
 
 Commands:
-    cog list                      List installed modules
-    cog run <module> <input>      Run a module
-    cog validate <module>         Validate module structure
-    cog install <source>          Install module from git/local/registry
-    cog uninstall <module>        Remove an installed module
-    cog init <name>               Create a new module from template
-    cog search <query>            Search the public registry
-    cog doctor                    Check environment setup
-    cog info <module>             Show module details
+    cogn list                      List installed modules
+    cogn run <module> <input>      Run a module
+    cogn validate <module>         Validate module structure
+    cogn add <url> --module <name> Add module from GitHub (recommended)
+    cogn update <module>           Update module to latest version
+    cogn versions <url>            List available versions for a repo
+    cogn install <source>          Install module from git/local/registry
+    cogn remove <module>           Remove an installed module
+    cogn uninstall <module>        Remove an installed module (alias)
+    cogn init <name>               Create a new module from template
+    cogn search <query>            Search the public registry
+    cogn doctor                    Check environment setup
+    cogn info <module>             Show module details
+    cogn serve                     Start HTTP API server
+    cogn mcp                       Start MCP server for Claude/Cursor
 """
 
 import json
@@ -31,6 +37,11 @@ from .registry import (
     uninstall_module,
     search_registry,
     fetch_registry,
+    install_from_github_url,
+    update_module,
+    get_installed_module_info,
+    get_module_version,
+    list_github_tags,
     USER_MODULES_DIR,
 )
 from .loader import load_module, detect_format
@@ -38,6 +49,7 @@ from .runner import run_module
 from .subagent import run_with_subagents
 from .validator import validate_module
 from .templates import create_module
+from .migrate import migrate_module, migrate_all_modules
 from .providers import check_provider_status
 
 app = typer.Typer(
@@ -151,11 +163,19 @@ def run_cmd(
 @app.command("validate")
 def validate_cmd(
     module: str = typer.Argument(..., help="Module name or path"),
+    v22: bool = typer.Option(False, "--v22", help="Validate v2.2 format requirements"),
 ):
-    """Validate a cognitive module's structure and examples."""
-    rprint(f"[cyan]→[/cyan] Validating module: [bold]{module}[/bold]\n")
+    """
+    Validate a cognitive module's structure and examples.
     
-    is_valid, errors, warnings = validate_module(module)
+    Examples:
+        cogn validate code-reviewer
+        cogn validate code-reviewer --v22   # Check v2.2 requirements
+    """
+    mode_str = " [dim](v2.2 strict)[/dim]" if v22 else ""
+    rprint(f"[cyan]→[/cyan] Validating module: [bold]{module}[/bold]{mode_str}\n")
+    
+    is_valid, errors, warnings = validate_module(module, v22=v22)
     
     if warnings:
         rprint(f"[yellow]⚠ Warnings ({len(warnings)}):[/yellow]")
@@ -164,7 +184,10 @@ def validate_cmd(
         print()
     
     if is_valid:
-        rprint(f"[green]✓ Module '{module}' is valid[/green]")
+        if v22:
+            rprint(f"[green]✓ Module '{module}' is valid v2.2 format[/green]")
+        else:
+            rprint(f"[green]✓ Module '{module}' is valid[/green]")
     else:
         rprint(f"[red]✗ Validation failed ({len(errors)} errors):[/red]")
         for e in errors:
@@ -172,6 +195,83 @@ def validate_cmd(
         raise typer.Exit(1)
 
 
+@app.command("migrate")
+def migrate_cmd(
+    module: Optional[str] = typer.Argument(None, help="Module name or path (omit for --all)"),
+    all_modules: bool = typer.Option(False, "--all", "-a", help="Migrate all installed modules"),
+    dry_run: bool = typer.Option(False, "--dry-run", "-n", help="Show what would be done without making changes"),
+    no_backup: bool = typer.Option(False, "--no-backup", help="Skip creating backup before migration"),
+):
+    """
+    Migrate modules from v1/v2.1 to v2.2 format.
+    
+    Examples:
+        cogn migrate code-reviewer          # Migrate single module
+        cogn migrate code-reviewer --dry-run # Preview changes
+        cogn migrate --all                  # Migrate all modules
+    """
+    if not module and not all_modules:
+        rprint("[red]Error: Provide module name or use --all[/red]")
+        raise typer.Exit(1)
+    
+    if all_modules:
+        rprint(f"[cyan]→[/cyan] Migrating all modules to v2.2...")
+        if dry_run:
+            rprint("[dim](dry run - no changes will be made)[/dim]")
+        print()
+        
+        results = migrate_all_modules(dry_run=dry_run, backup=not no_backup)
+        
+        success_count = 0
+        for name, success, changes, warnings in results:
+            if success:
+                success_count += 1
+                rprint(f"[green]✓[/green] {name}")
+                for c in changes:
+                    rprint(f"    {c}")
+            else:
+                rprint(f"[red]✗[/red] {name}")
+                for w in warnings:
+                    rprint(f"    [yellow]{w}[/yellow]")
+        
+        print()
+        rprint(f"[green]Migrated: {success_count}/{len(results)}[/green]")
+        
+    else:
+        mode_str = " [dim](dry run)[/dim]" if dry_run else ""
+        rprint(f"[cyan]→[/cyan] Migrating module: [bold]{module}[/bold]{mode_str}\n")
+        
+        success, changes, warnings = migrate_module(
+            module,
+            dry_run=dry_run,
+            backup=not no_backup
+        )
+        
+        if changes:
+            rprint(f"[cyan]Changes:[/cyan]")
+            for c in changes:
+                rprint(f"  - {c}")
+            print()
+        
+        if warnings:
+            rprint(f"[yellow]⚠ Warnings:[/yellow]")
+            for w in warnings:
+                rprint(f"  - {w}")
+            print()
+        
+        if success:
+            if dry_run:
+                rprint(f"[green]✓ Migration preview complete[/green]")
+                rprint(f"  Run without --dry-run to apply changes")
+            else:
+                rprint(f"[green]✓ Module '{module}' migrated to v2.2[/green]")
+                rprint(f"\nValidate with:")
+                rprint(f"  [cyan]cogn validate {module} --v22[/cyan]")
+        else:
+            rprint(f"[red]✗ Migration failed[/red]")
+            raise typer.Exit(1)
+
+
 @app.command("install")
 def install_cmd(
     source: str = typer.Argument(..., help="Source: github:org/repo/path, registry:name, or local path"),
@@ -203,6 +303,185 @@ def install_cmd(
         raise typer.Exit(1)
 
 
+@app.command("add")
+def add_cmd(
+    url: str = typer.Argument(..., help="GitHub URL or org/repo shorthand"),
+    module: str = typer.Option(None, "--module", "-m", help="Module path within repo"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Override module name"),
+    branch: str = typer.Option("main", "--branch", "-b", help="Git branch"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Git tag/version (e.g., v1.0.0)"),
+):
+    """
+    Add a cognitive module from GitHub.
+    
+    Examples:
+    
+        cog add https://github.com/ziel-io/cognitive-modules --module code-simplifier
+        
+        cog add ziel-io/cognitive-modules -m code-reviewer
+        
+        cog add org/repo -m my-module --tag v1.0.0
+        
+        cog add org/repo -m path/to/module --name my-module
+    """
+    rprint(f"[cyan]→[/cyan] Adding module from: {url}")
+    if module:
+        rprint(f"  Module path: {module}")
+    if tag:
+        rprint(f"  Version: {tag}")
+    
+    try:
+        target = install_from_github_url(
+            url=url,
+            module_path=module,
+            name=name,
+            branch=branch,
+            tag=tag,
+        )
+        
+        # Validate installed module
+        is_valid, errors, warnings = validate_module(str(target))
+        
+        if not is_valid:
+            rprint(f"[red]✗ Installed module failed validation:[/red]")
+            for e in errors:
+                rprint(f"  - {e}")
+            uninstall_module(target.name)
+            raise typer.Exit(1)
+        
+        # Get version info
+        version = get_module_version(target)
+        version_str = f" v{version}" if version else ""
+        
+        rprint(f"[green]✓ Added: {target.name}{version_str}[/green]")
+        rprint(f"  Location: {target}")
+        
+        if warnings:
+            rprint(f"[yellow]  Warnings: {len(warnings)}[/yellow]")
+        
+        rprint(f"\nRun with:")
+        rprint(f"  [cyan]cog run {target.name} --args \"your input\"[/cyan]")
+        
+    except Exception as e:
+        rprint(f"[red]✗ Failed to add module: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("remove")
+def remove_cmd(
+    module: str = typer.Argument(..., help="Module name to remove"),
+):
+    """Remove an installed cognitive module (alias for uninstall)."""
+    uninstall_cmd(module)
+
+
+@app.command("update")
+def update_cmd(
+    module: str = typer.Argument(..., help="Module name to update"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Update to specific tag/version"),
+):
+    """
+    Update an installed module to the latest version.
+    
+    Examples:
+    
+        cog update code-simplifier
+        
+        cog update code-simplifier --tag v2.0.0
+    """
+    rprint(f"[cyan]→[/cyan] Updating module: {module}")
+    
+    # Check if module is installed
+    info = get_installed_module_info(module)
+    if not info:
+        rprint(f"[red]✗ Module not found or not installed from GitHub: {module}[/red]")
+        rprint(f"  Only modules installed with 'cog add' can be updated.")
+        raise typer.Exit(1)
+    
+    github_url = info.get("github_url")
+    if not github_url:
+        rprint(f"[red]✗ Module was not installed from GitHub: {module}[/red]")
+        raise typer.Exit(1)
+    
+    # Get current version
+    current_path = USER_MODULES_DIR / module
+    old_version = get_module_version(current_path) if current_path.exists() else None
+    
+    if old_version:
+        rprint(f"  Current version: {old_version}")
+    
+    try:
+        # Re-install from source
+        module_path = info.get("module_path")
+        branch = info.get("branch", "main")
+        
+        # Use specified tag or keep using the same ref type
+        use_tag = tag or info.get("tag")
+        
+        target = install_from_github_url(
+            url=github_url,
+            module_path=module_path,
+            name=module,
+            branch=branch if not use_tag else "main",
+            tag=use_tag,
+        )
+        
+        # Get new version
+        new_version = get_module_version(target)
+        
+        if old_version and new_version:
+            if old_version == new_version:
+                rprint(f"[green]✓ Already up to date: {module} v{new_version}[/green]")
+            else:
+                rprint(f"[green]✓ Updated: {module} v{old_version} → v{new_version}[/green]")
+        elif new_version:
+            rprint(f"[green]✓ Updated: {module} to v{new_version}[/green]")
+        else:
+            rprint(f"[green]✓ Updated: {module}[/green]")
+        
+    except Exception as e:
+        rprint(f"[red]✗ Failed to update module: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command("versions")
+def versions_cmd(
+    url: str = typer.Argument(..., help="GitHub URL or org/repo shorthand"),
+    limit: int = typer.Option(10, "--limit", "-l", help="Max versions to show"),
+):
+    """
+    List available versions (tags) for a GitHub repository.
+    
+    Examples:
+    
+        cog versions ziel-io/cognitive-modules
+        
+        cog versions https://github.com/org/repo
+    """
+    rprint(f"[cyan]→[/cyan] Fetching versions from: {url}\n")
+    
+    try:
+        tags = list_github_tags(url, limit=limit)
+        
+        if not tags:
+            rprint("[yellow]No tags/versions found.[/yellow]")
+            return
+        
+        table = Table(title=f"Available Versions ({len(tags)})")
+        table.add_column("Version", style="cyan")
+        table.add_column("Install Command")
+        
+        for tag in tags:
+            cmd = f"cog add {url} --tag {tag}"
+            table.add_row(tag, f"[dim]{cmd}[/dim]")
+        
+        console.print(table)
+        
+    except Exception as e:
+        rprint(f"[red]✗ Failed to fetch versions: {e}[/red]")
+        raise typer.Exit(1)
+
+
 @app.command("uninstall")
 def uninstall_cmd(
     module: str = typer.Argument(..., help="Module name to uninstall"),
@@ -403,6 +682,84 @@ def info_cmd(
     
     rprint(f"\n[bold]Path:[/bold] {m['path']}")
     rprint(f"[bold]Prompt size:[/bold] {len(m['prompt'])} chars")
+    
+    # Show installation info if available
+    install_info = get_installed_module_info(meta.get('name', module))
+    if install_info:
+        rprint(f"\n[bold]Installation:[/bold]")
+        if install_info.get("github_url"):
+            rprint(f"  Source: {install_info['github_url']}")
+        if install_info.get("tag"):
+            rprint(f"  Tag: {install_info['tag']}")
+        elif install_info.get("branch"):
+            rprint(f"  Branch: {install_info['branch']}")
+        if install_info.get("installed_time"):
+            rprint(f"  Installed: {install_info['installed_time'][:10]}")
+        rprint(f"\n  Update with: [cyan]cog update {meta.get('name', module)}[/cyan]")
+
+
+@app.command("serve")
+def serve_cmd(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind"),
+    port: int = typer.Option(8000, "--port", "-p", help="Port to bind"),
+):
+    """
+    Start HTTP API server for workflow integration.
+    
+    Example:
+        cogn serve --port 8000
+        
+    Then use:
+        curl -X POST http://localhost:8000/run \\
+          -H "Content-Type: application/json" \\
+          -d '{"module": "code-reviewer", "args": "your code"}'
+    """
+    try:
+        import uvicorn
+    except ImportError:
+        rprint("[red]Error:[/red] Server dependencies not installed.")
+        rprint("\nInstall with:")
+        rprint("  [cyan]pip install cognitive-modules[server][/cyan]")
+        raise typer.Exit(1)
+    
+    rprint(f"[green]Starting Cognitive API server...[/green]")
+    rprint(f"  Host: {host}")
+    rprint(f"  Port: {port}")
+    rprint(f"  Docs: http://{host if host != '0.0.0.0' else 'localhost'}:{port}/docs")
+    rprint()
+    
+    uvicorn.run("cognitive.server:app", host=host, port=port, reload=False)
+
+
+@app.command("mcp")
+def mcp_cmd():
+    """
+    Start MCP (Model Context Protocol) server.
+    
+    Enables Claude Code, Cursor, and other MCP-compatible tools to use Cognitive Modules.
+    
+    Example:
+        cogn mcp
+        
+    Configure in Claude Desktop (claude_desktop_config.json):
+        {
+          "mcpServers": {
+            "cognitive": {
+              "command": "cogn",
+              "args": ["mcp"]
+            }
+          }
+        }
+    """
+    try:
+        from .mcp_server import serve
+    except ImportError:
+        rprint("[red]Error:[/red] MCP dependencies not installed.")
+        rprint("\nInstall with:")
+        rprint("  [cyan]pip install cognitive-modules[mcp][/cyan]")
+        raise typer.Exit(1)
+    
+    serve()
 
 
 @app.callback(invoke_without_command=True)