@mc1global/opencode-jarvis 0.13.0 → 0.13.1

package/scripts/kanban_session_manager.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Kanban Session Manager CLI - Session lifecycle and state export/import.
+
+Manages the binding between Context Memory sessions and Kanban DBs.
+TOON output format for token efficiency.
+
+Usage:
+    python scripts/kanban_session_manager.py attach -w X -s SESSION_ID
+    python scripts/kanban_session_manager.py status -w X
+    python scripts/kanban_session_manager.py export-state -w X --format=json
+"""
+
+import click
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.application.kanban import SessionKanbanIntegration, KanbanService
+
+
+@click.group()
+def cli():
+    """Kanban Session Manager - Session lifecycle and state management."""
+    pass
+
+
+@cli.command('attach')
+@click.option('--workspace', '-w', required=True)
+@click.option('--session-id', '-s', required=True, help='Context Memory session ID')
+def attach(workspace, session_id):
+    """Attach Kanban DB to current session."""
+    result = SessionKanbanIntegration().attach_kanban_db(workspace, session_id)
+    if result.success:
+        click.echo(f"ok:attached:{result.data['db_path']},session:{session_id}")
+    else:
+        click.echo(f"err:{result.error}")
+
+
+@cli.command('detach')
+@click.option('--session-id', '-s', required=True, help='Context Memory session ID')
+def detach(session_id):
+    """Detach Kanban DB from current session."""
+    result = SessionKanbanIntegration().detach_kanban_db(session_id)
+    if result.success:
+        click.echo(f"ok:detached:{result.data['detached_path']}")
+    else:
+        click.echo(f"err:{result.error}")
+
+
+@cli.command('status')
+@click.option('--workspace', '-w', required=True)
+def status(workspace):
+    """Show session-kanban linkage for workspace."""
+    result = SessionKanbanIntegration().get_status(workspace)
+    s = result.data
+    click.echo(f"workspace:{s['workspace']}")
+    click.echo(f"kanban_db_exists:{s['kanban_db_exists']}")
+    if s['kanban_db_path']:
+        click.echo(f"kanban_db_path:{s['kanban_db_path']}")
+    click.echo(f"active_session:{s['active_session_id'] or 'none'}")
+    if s['active_session_id']:
+        click.echo(f"session_state:{s['session_state']}")
+        click.echo(f"linked_kanban_db:{s['linked_kanban_db'] or 'none'}")
+
+
+@cli.command('list-dbs')
+def list_dbs():
+    """List all Kanban databases."""
+    dbs = SessionKanbanIntegration().list_all_dbs()
+    if not dbs:
+        click.echo("ok:no_dbs")
+        return
+
+    click.echo(f"ok:count:{len(dbs)}")
+    for db in dbs:
+        click.echo(f"  {db['workspace']}:{db['size_kb']}KB:{db['path']}")
+
+
+@cli.command('export-state')
+@click.option('--workspace', '-w', required=True)
+@click.option('--output', '-o', help='Output file (default: stdout)')
+@click.option('--format', 'fmt', type=click.Choice(['json', 'toon']), default='toon')
+def export_state(workspace, output, fmt):
+    """Export Kanban state for session continuity."""
+    service = KanbanService(workspace)
+    result = service.export_state()
+
+    if not result.success:
+        click.echo(f"err:{result.error}")
+        return
+
+    state = result.data
+    if fmt == 'json':
+        out = json.dumps(state, indent=2)
+    else:
+        out = service.format_state_toon(state)
+
+    if output:
+        with open(output, 'w') as f:
+            f.write(out)
+        click.echo(f"ok:exported:{output}")
+    else:
+        click.echo(out)
+
+
+@cli.command('import-state')
+@click.option('--workspace', '-w', required=True)
+@click.option('--input', 'input_file', required=True, help='Input JSON file')
+@click.option('--confirm', is_flag=True, help='Confirm import (required)')
+def import_state(workspace, input_file, confirm):
+    """Import Kanban state from previous session (requires --confirm)."""
+    if not confirm:
+        click.echo("err:requires_confirmation")
+        click.echo("warn:use --confirm to import state.")
+        return
+
+    input_path = Path(input_file)
+    if not input_path.exists():
+        click.echo(f"err:file_not_found:{input_file}")
+        return
+
+    with open(input_path) as f:
+        try:
+            state = json.load(f)
+        except json.JSONDecodeError as e:
+            click.echo(f"err:invalid_json:{e}")
+            return
+
+    service = KanbanService(workspace)
+    result = service.parse_import_state(state)
+
+    if not result.success:
+        click.echo(f"warn:{result.error}")
+
+    data = result.data
+    click.echo(f"state_from:{data['exported_at']}")
+    click.echo(f"sprints:{data['sprints_count']},epics:{data['epics_count']},cards:{data['cards_count']}")
+
+    if data['wip_cards']:
+        click.echo("wip_cards_to_continue:")
+        for c in data['wip_cards']:
+            click.echo(f"  {c['id']}:{c['status']}:{c['title'][:40]}")
+
+    click.echo("ok:state_loaded_for_reference")
+
+
+if __name__ == '__main__':
+    cli()

package/scripts/llm/code_generator_with_governance.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""
+Code Generator with Governance Context Injection.
+
+Extends llm_ops.py to inject SOLID/DDD governance context before code generation.
+Communicates with code-reviewer agent via context_memory.
+
+Type Hints: Required
+Docstring: Google format
+Max Lines: 400
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional, Dict
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from scripts.llm.llm_ops import LLMOperations
+import subprocess
+
+
+class CodeGeneratorWithGovernance:
+    """Code generator with automatic governance context injection."""
+
+    def __init__(self):
+        """Initialize code generator with governance."""
+        self.llm_ops = LLMOperations()
+        self.governance_doc = Path(__file__).parent.parent.parent / \
+            "docs" / "architecture" / "SOLID_DDD_IMPLEMENTATION.md"
+        self.governance_context = None
+
+    def _load_governance_context(self) -> str:
+        """
+        Load governance context from SOLID_DDD_IMPLEMENTATION.md.
+
+        Returns:
+            Governance rules text (first 200 lines for token efficiency)
+        """
+        if self.governance_context is None:
+            if not self.governance_doc.exists():
+                print("⚠️  Governance doc not found, proceeding without context")
+                return ""
+
+            # Load first 200 lines (core principles)
+            with open(self.governance_doc) as f:
+                lines = [f.readline() for _ in range(200)]
+                self.governance_context = ''.join(lines)
+
+        return self.governance_context
+
+    def _inject_governance_to_prompt(self, user_request: str) -> str:
+        """
+        Inject governance context into user request.
+
+        Args:
+            user_request: Original code generation request
+
+        Returns:
+            Enhanced request with governance context
+        """
+        governance = self._load_governance_context()
+
+        # Inject governance as reference context
+        enhanced_request = f"""# CODE GENERATION REQUEST
+
+## User Request:
+{user_request}
+
+## GOVERNANCE CONTEXT (MANDATORY COMPLIANCE):
+
+{governance}
+
+## REQUIREMENTS:
+1. Follow SOLID principles strictly
+2. Implement DDD patterns where applicable
+3. Max file length: 400 lines (Python)
+4. Google-style docstrings required
+5. Type hints required (Python 3.11+)
+6. No hardcoded credentials
+7. Explicit error handling
+
+Generate code complying with all governance rules above.
+"""
+        return enhanced_request
+
+    def _notify_context_memory(
+        self,
+        file_path: str,
+        status: str,
+        details: Optional[str] = None
+    ) -> None:
+        """
+        Notify context_memory about generation status.
+
+        Args:
+            file_path: Path to generated file
+            status: pending-review|generation-failed
+            details: Additional context
+        """
+        tags = f"{status},code-generation"
+        content = f"Generated: {file_path}"
+        if details:
+            content += f" | Details: {details}"
+
+        subprocess.run([
+            "python",
+            "scripts/context_memory_cli.py",
+            "note",
+            "add",
+            content,
+            f"--tags={tags}"
+        ], check=False, capture_output=True)
+
+    def _strip_markdown_fences(self, code: str) -> str:
+        """
+        Remove markdown code fences from generated code.
+
+        Args:
+            code: Raw code from LLM (may contain ```python ... ```)
+
+        Returns:
+            Clean code without markdown fences
+        """
+        lines = code.strip().split('\n')
+
+        # Remove leading fence (```python, ```py, ```)
+        if lines and lines[0].strip().startswith('```'):
+            lines = lines[1:]
+
+        # Remove trailing fence (```)
+        if lines and lines[-1].strip() == '```':
+            lines = lines[:-1]
+
+        return '\n'.join(lines)
+
+    def generate_code(
+        self,
+        request: str,
+        output_path: Optional[str] = None,
+        notify_reviewer: bool = True
+    ) -> str:
+        """
+        Generate code with governance context injection.
+
+        Args:
+            request: Code generation request
+            output_path: Where to save generated code
+            notify_reviewer: Whether to notify code-reviewer via context_memory
+
+        Returns:
+            Generated code
+
+        Raises:
+            RuntimeError: If code generation fails
+        """
+        print("📝 Preparing code generation request...")
+
+        # Inject governance context
+        enhanced_request = self._inject_governance_to_prompt(request)
+
+        # Generate code using llm_ops
+        print("🤖 Generating code with Ollama (gpt-oss:20b)...")
+        try:
+            generated_code = self.llm_ops.execute(
+                use_case="code_generation",
+                content=enhanced_request,
+                output_format="text"
+            )
+        except Exception as e:
+            if output_path:
+                self._notify_context_memory(
+                    output_path,
+                    "generation-failed",
+                    str(e)
+                )
+            raise RuntimeError(f"Code generation failed: {e}")
+
+        # Clean markdown fences if present
+        generated_code = self._strip_markdown_fences(generated_code)
+
+        # Save to file if specified
+        if output_path:
+            Path(output_path).write_text(generated_code)
+            print(f"✅ Code written to: {output_path}")
+
+            # Notify context_memory for code-reviewer
+            if notify_reviewer:
+                self._notify_context_memory(
+                    output_path,
+                    "pending-review",
+                    f"Awaiting code-reviewer validation"
+                )
+                print("📬 Notified code-reviewer agent via context_memory")
+
+        return generated_code
+
+    def generate_with_review_loop(
+        self,
+        request: str,
+        output_path: str,
+        max_iterations: int = 3
+    ) -> Dict[str, str]:
+        """
+        Generate code and wait for reviewer feedback (loop).
+
+        Args:
+            request: Code generation request
+            output_path: Where to save generated code
+            max_iterations: Max revision cycles
+
+        Returns:
+            Dict with status and final_code
+        """
+        iteration = 0
+        current_request = request
+
+        while iteration < max_iterations:
+            iteration += 1
+            print(f"\n🔄 Iteration {iteration}/{max_iterations}")
+
+            # Generate code
+            generated_code = self.generate_code(
+                current_request,
+                output_path,
+                notify_reviewer=True
+            )
+
+            # Wait for reviewer feedback via context_memory
+            print("⏳ Waiting for code-reviewer feedback...")
+            print("   (Check context_memory for review status)")
+
+            # In real implementation, would poll context_memory
+            # For now, return pending status
+            return {
+                "status": "pending_review",
+                "final_code": generated_code,
+                "iteration": iteration,
+                "output_path": output_path
+            }
+
+        return {
+            "status": "max_iterations_reached",
+            "final_code": generated_code,
+            "iteration": iteration
+        }
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description='Code Generator with Governance Context Injection'
+    )
+
+    parser.add_argument(
+        'request',
+        help='Code generation request (or use --input for file)'
+    )
+    parser.add_argument(
+        '--input', '-i',
+        help='Read request from file instead of CLI arg'
+    )
+    parser.add_argument(
+        '--output', '-o',
+        required=True,
+        help='Output file path for generated code'
+    )
+    parser.add_argument(
+        '--no-review',
+        action='store_true',
+        help='Skip code-reviewer notification'
+    )
+    parser.add_argument(
+        '--review-loop',
+        action='store_true',
+        help='Enable automatic review loop (experimental)'
+    )
+
+    args = parser.parse_args()
+
+    # Read request
+    if args.input:
+        request = Path(args.input).read_text()
+    else:
+        request = args.request
+
+    # Initialize generator
+    generator = CodeGeneratorWithGovernance()
+
+    # Generate code
+    try:
+        if args.review_loop:
+            result = generator.generate_with_review_loop(
+                request,
+                args.output
+            )
+            print(f"\n📊 Result: {result['status']}")
+            print(f"   Iterations: {result['iteration']}")
+        else:
+            generated_code = generator.generate_code(
+                request,
+                args.output,
+                notify_reviewer=not args.no_review
+            )
+            print(f"\n✅ Generation complete!")
+            print(f"   Output: {args.output}")
+            if not args.no_review:
+                print(f"   Status: Pending code-reviewer validation")
+
+    except Exception as e:
+        print(f"❌ Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/llm/llm_ops.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+"""
+LLM Operations - Unified LangChain + Ollama interface.
+
+Provides parametrized LLM operations using prompts from config/llm_prompts.yaml
+Zero-cost local processing with Ollama.
+
+Type Hints: Required
+Docstring: Google format
+Max Lines: 400
+"""
+
+import argparse
+import json
+import sys
+import time
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Add project root to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from langchain_ollama import ChatOllama
+from langchain_core.prompts import ChatPromptTemplate
+
+
+class LLMOperations:
+    """Unified LLM operations with parametrized prompts."""
+
+    def __init__(self, config_path: Optional[str] = None):
+        """
+        Initialize LLM operations.
+
+        Args:
+            config_path: Path to llm_prompts.yaml (default: config/llm_prompts.yaml)
+        """
+        if config_path is None:
+            config_path = Path(__file__).parent.parent.parent / "config" / "llm_prompts.yaml"
+
+        self.config = self._load_config(config_path)
+        self.defaults = self.config['llm']['defaults']
+        self.use_cases = self.config['llm']['use_cases']
+
+    def _load_config(self, config_path: Path) -> Dict:
+        """Load configuration from YAML."""
+        if not config_path.exists():
+            raise FileNotFoundError(f"Config not found: {config_path}")
+
+        with open(config_path) as f:
+            return yaml.safe_load(f)
+
+    def execute(
+        self,
+        use_case: str,
+        content: str,
+        variables: Optional[Dict[str, str]] = None,
+        output_format: str = "text"
+    ) -> str:
+        """
+        Execute LLM operation.
+
+        Args:
+            use_case: Use case name from config (e.g., 'code_analysis')
+            content: Input content to process
+            variables: Optional variables for prompt formatting
+            output_format: text|json
+
+        Returns:
+            LLM response (text or JSON string)
+
+        Raises:
+            ValueError: If use_case not found
+            RuntimeError: If LLM execution fails
+        """
+        if use_case not in self.use_cases:
+            available = ', '.join(self.use_cases.keys())
+            raise ValueError(f"Use case '{use_case}' not found. Available: {available}")
+
+        config = self.use_cases[use_case]
+
+        # Format system prompt with variables
+        system_prompt = config['system_prompt']
+        if variables:
+            system_prompt = system_prompt.format(**variables)
+
+        # Create LLM
+        llm = ChatOllama(
+            model=config['model'],
+            base_url=self.defaults['host'],
+            temperature=config['temperature'],
+            num_predict=config.get('max_tokens', 2000),
+            timeout=self.defaults['timeout']
+        )
+
+        # Create prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", system_prompt),
+            ("human", "{content}")
+        ])
+
+        # Execute
+        print(f"🤖 Using: {config['model']} (temp={config['temperature']})")
+        start = time.time()
+
+        try:
+            chain = prompt | llm
+            result = chain.invoke({"content": content})
+            response = result.content
+
+            elapsed = time.time() - start
+            print(f"✅ Completed in {elapsed:.1f}s")
+
+            # Validate JSON if expected
+            if output_format == "json":
+                json.loads(response)  # Validate
+
+            return response
+
+        except json.JSONDecodeError as e:
+            print(f"⚠️  Invalid JSON response. Returning raw text.")
+            return result.content
+        except Exception as e:
+            elapsed = time.time() - start
+            raise RuntimeError(f"LLM execution failed after {elapsed:.1f}s: {e}")
+
+    def list_use_cases(self) -> Dict[str, str]:
+        """
+        List available use cases.
+
+        Returns:
+            Dict of {use_case: model}
+        """
+        return {
+            name: config['model']
+            for name, config in self.use_cases.items()
+        }
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description='LLM Operations - Unified Ollama interface'
+    )
+
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+
+    # execute command
+    exec_parser = subparsers.add_parser('execute', help='Execute LLM operation')
+    exec_parser.add_argument('use_case', help='Use case name')
+    exec_parser.add_argument('--input', '-i', help='Input file (or stdin)')
+    exec_parser.add_argument('--output', '-o', help='Output file (or stdout)')
+    exec_parser.add_argument('--format', '-f', choices=['text', 'json'],
+                            default='text', help='Output format')
+    exec_parser.add_argument('--var', action='append', help='Variables (key=value)')
+
+    # list command
+    subparsers.add_parser('list', help='List available use cases')
+
+    args = parser.parse_args()
+
+    # Initialize
+    ops = LLMOperations()
+
+    # Execute command
+    if args.command == 'execute':
+        # Read input
+        if args.input:
+            content = Path(args.input).read_text()
+        else:
+            content = sys.stdin.read()
+
+        # Parse variables
+        variables = {}
+        if args.var:
+            for var in args.var:
+                key, value = var.split('=', 1)
+                variables[key] = value
+
+        # Execute
+        result = ops.execute(
+            use_case=args.use_case,
+            content=content,
+            variables=variables,
+            output_format=args.format
+        )
+
+        # Output
+        if args.output:
+            Path(args.output).write_text(result)
+            print(f"✅ Output written to: {args.output}")
+        else:
+            print(result)
+
+    elif args.command == 'list':
+        use_cases = ops.list_use_cases()
+        print("\n📋 Available LLM Use Cases:\n")
+        for name, model in use_cases.items():
+            print(f"  • {name:<25} → {model}")
+        print()
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()