cognova 0.1.0

package/Claude/skills/environment/environment.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Environment Skill for Cognova
+
+Provides system information, service status, and troubleshooting utilities.
+
+Usage:
+    python environment.py info
+    python environment.py status
+    python environment.py logs [--lines N]
+    python environment.py health
+"""
+
+import argparse
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / '_lib'))
+
+from api import api_request, API_BASE
+
+INSTALL_DIR = os.environ.get('COGNOVA_PROJECT_DIR', '')
+VAULT_PATH = os.environ.get('VAULT_PATH', '')
+
+
+def cmd_info(args):
+    """Show system and installation information."""
+    print("=== Cognova Environment ===\n")
+
+    # System
+    print(f"OS:           {platform.system()} {platform.release()}")
+    print(f"Architecture: {platform.machine()}")
+    print(f"Python:       {platform.python_version()}")
+
+    try:
+        node_v = subprocess.run(['node', '--version'], capture_output=True, text=True, timeout=5)
+        print(f"Node.js:      {node_v.stdout.strip()}")
+    except Exception:
+        print("Node.js:      not found")
+
+    print()
+
+    # Paths
+    print(f"Install Dir:  {INSTALL_DIR or '(not set)'}")
+    print(f"Vault Path:   {VAULT_PATH or '(not set)'}")
+    print(f"API URL:      {API_BASE}")
+    print(f"Home Claude:  {Path.home() / '.claude'}")
+
+    # Metadata
+    meta_path = Path.home() / '.cognova'
+    if meta_path.exists():
+        try:
+            meta = json.loads(meta_path.read_text())
+            print(f"Version:      {meta.get('version', 'unknown')}")
+            print(f"Installed:    {meta.get('installedAt', 'unknown')[:10]}")
+            if meta.get('updatedAt'):
+                print(f"Updated:      {meta['updatedAt'][:10]}")
+        except Exception:
+            pass
+
+    print()
+
+    # Disk
+    check_dir = INSTALL_DIR or str(Path.home())
+    if Path(check_dir).exists():
+        usage = shutil.disk_usage(check_dir)
+        total_gb = usage.total / (1024**3)
+        used_gb = usage.used / (1024**3)
+        free_gb = usage.free / (1024**3)
+        pct = (usage.used / usage.total) * 100
+        print(f"Disk Total:   {total_gb:.1f} GB")
+        print(f"Disk Used:    {used_gb:.1f} GB ({pct:.0f}%)")
+        print(f"Disk Free:    {free_gb:.1f} GB")
+
+    # Memory
+    try:
+        if platform.system() == 'Linux':
+            with open('/proc/meminfo') as f:
+                meminfo = f.read()
+            for line in meminfo.split('\n'):
+                if line.startswith('MemTotal:'):
+                    total_kb = int(line.split()[1])
+                    print(f"\nRAM Total:    {total_kb / (1024**2):.1f} GB")
+                elif line.startswith('MemAvailable:'):
+                    avail_kb = int(line.split()[1])
+                    print(f"RAM Available:{avail_kb / (1024**2):.1f} GB")
+    except Exception:
+        pass
+
+    # Vault stats
+    if VAULT_PATH and Path(VAULT_PATH).exists():
+        vault = Path(VAULT_PATH)
+        md_files = list(vault.rglob('*.md'))
+        print(f"\nVault Files:  {len(md_files)} markdown documents")
+
+        folders = ['inbox', 'projects', 'areas', 'resources', 'archive']
+        for folder in folders:
+            folder_path = vault / folder
+            if folder_path.exists():
+                count = len(list(folder_path.rglob('*.md')))
+                print(f"  {folder}/: {count} files")
+
+
+def cmd_status(args):
+    """Check service status."""
+    print("=== Service Status ===\n")
+
+    # PM2
+    try:
+        result = subprocess.run(
+            ['pm2', 'jlist'],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            processes = json.loads(result.stdout)
+            sb = [p for p in processes if p.get('name') == 'cognova']
+            if sb:
+                proc = sb[0]
+                env = proc.get('pm2_env', {})
+                monit = proc.get('monit', {})
+                status = env.get('status', 'unknown')
+                restarts = env.get('restart_time', 0)
+                memory = monit.get('memory', 0)
+                cpu = monit.get('cpu', 0)
+                mem_mb = memory / (1024 * 1024)
+
+                print(f"PM2 Status:   {status}")
+                print(f"Memory:       {mem_mb:.0f} MB")
+                print(f"CPU:          {cpu}%")
+                print(f"Restarts:     {restarts}")
+            else:
+                print("PM2 Status:   not found (process 'cognova' not registered)")
+        else:
+            print("PM2 Status:   error running pm2")
+    except FileNotFoundError:
+        print("PM2 Status:   pm2 not installed")
+    except Exception as e:
+        print(f"PM2 Status:   error ({e})")
+
+    print()
+
+    # API health
+    try:
+        start = time.time()
+        ok, data = api_request('GET', '/health')
+        elapsed = (time.time() - start) * 1000
+        if ok:
+            print(f"API:          healthy ({elapsed:.0f}ms)")
+            if isinstance(data, dict):
+                for k, v in data.items():
+                    print(f"  {k}: {v}")
+        else:
+            print(f"API:          unhealthy — {data}")
+    except Exception as e:
+        print(f"API:          unreachable ({e})")
+
+
+def cmd_logs(args):
+    """Show recent PM2 logs."""
+    lines = args.lines or 30
+    try:
+        result = subprocess.run(
+            ['pm2', 'logs', 'cognova', '--lines', str(lines), '--nostream'],
+            capture_output=True, text=True, timeout=15
+        )
+        if result.stdout:
+            print(result.stdout)
+        if result.stderr:
+            print(result.stderr)
+    except FileNotFoundError:
+        print("ERROR: pm2 not installed")
+        sys.exit(1)
+    except Exception as e:
+        print(f"ERROR: {e}")
+        sys.exit(1)
+
+
+def cmd_health(args):
+    """Detailed API health check."""
+    endpoints = [
+        ('GET', '/health', 'Health'),
+        ('GET', '/tasks', 'Tasks'),
+        ('GET', '/projects', 'Projects'),
+        ('GET', '/documents', 'Documents'),
+        ('GET', '/memory/search', 'Memory'),
+    ]
+
+    print("=== API Health Check ===\n")
+    print(f"Base URL: {API_BASE}\n")
+
+    all_ok = True
+    for method, endpoint, label in endpoints:
+        start = time.time()
+        try:
+            ok, data = api_request(method, endpoint)
+            elapsed = (time.time() - start) * 1000
+            status = "OK" if ok else "FAIL"
+            if not ok:
+                all_ok = False
+            print(f"  {status:4s}  {label:15s}  {elapsed:6.0f}ms")
+        except Exception as e:
+            all_ok = False
+            print(f"  FAIL  {label:15s}  error: {e}")
+
+    print(f"\nOverall: {'All healthy' if all_ok else 'Some endpoints failing'}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Environment Skill')
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    subparsers.add_parser('info', help='Show system information')
+    subparsers.add_parser('status', help='Check service status')
+
+    logs_p = subparsers.add_parser('logs', help='Show recent logs')
+    logs_p.add_argument('--lines', '-n', type=int, default=30, help='Number of lines')
+
+    subparsers.add_parser('health', help='API health check')
+
+    args = parser.parse_args()
+
+    commands = {
+        'info': cmd_info,
+        'status': cmd_status,
+        'logs': cmd_logs,
+        'health': cmd_health,
+    }
+
+    commands[args.command](args)
+
+
+if __name__ == '__main__':
+    main()

package/Claude/skills/memory/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: memory
+description: Access persistent memory across Claude sessions. Search past conversations, recall decisions, store key insights. Use when needing context from previous work or to save important information for future sessions.
+allowed-tools: Bash, Read
+---
+
+# Memory Skill
+
+Access and manage persistent memory from previous Claude sessions. Memories are automatically extracted from conversations and can be explicitly stored.
+
+## Memory Types
+
+| Type | Icon | Description |
+|------|------|-------------|
+| `decision` | [D] | Architectural or design decisions made |
+| `fact` | [F] | Key facts or information learned |
+| `solution` | [S] | Solutions to problems encountered |
+| `pattern` | [P] | Patterns or conventions discovered |
+| `preference` | [*] | User or project preferences |
+| `summary` | [~] | Summarized context from sessions |
+
+## Commands
+
+### Search memories
+
+```bash
+python3 ~/.claude/skills/memory/memory.py search "<query>" [options]
+```
+
+Options:
+- `--type <type>` - Filter by memory type
+- `--project <path>` - Filter by project path
+- `--limit <n>` - Max results (default: 10)
+
+Examples:
+```bash
+python3 ~/.claude/skills/memory/memory.py search "authentication"
+python3 ~/.claude/skills/memory/memory.py search "database" --type decision
+python3 ~/.claude/skills/memory/memory.py search "API" --project "/Users/me/project"
+```
+
+### Get recent memories
+
+```bash
+python3 ~/.claude/skills/memory/memory.py recent [limit] [options]
+```
+
+Options:
+- `--type <type>` - Filter by memory type
+
+Examples:
+```bash
+python3 ~/.claude/skills/memory/memory.py recent
+python3 ~/.claude/skills/memory/memory.py recent 5
+python3 ~/.claude/skills/memory/memory.py recent --type decision
+```
+
+### Store a memory
+
+```bash
+python3 ~/.claude/skills/memory/memory.py store "<content>" [options]
+```
+
+Options:
+- `--type <type>` - Memory type (default: fact)
+- `--project <path>` - Associated project path
+- `--relevance <0-1>` - Relevance score (default: 0.9)
+
+Examples:
+```bash
+python3 ~/.claude/skills/memory/memory.py store "We use PostgreSQL with Drizzle ORM"
+python3 ~/.claude/skills/memory/memory.py store "API rate limit set to 100 req/min" --type decision
+python3 ~/.claude/skills/memory/memory.py store "User prefers pnpm over npm" --type preference
+```
+
+### List decisions
+
+```bash
+python3 ~/.claude/skills/memory/memory.py decisions [options]
+```
+
+Options:
+- `--project <path>` - Filter by project
+- `--limit <n>` - Max results (default: 20)
+
+Examples:
+```bash
+python3 ~/.claude/skills/memory/memory.py decisions
+python3 ~/.claude/skills/memory/memory.py decisions --project "cognova"
+```
+
+### Find memories about a topic
+
+```bash
+python3 ~/.claude/skills/memory/memory.py about "<topic>" [options]
+```
+
+Options:
+- `--limit <n>` - Max results (default: 15)
+
+Examples:
+```bash
+python3 ~/.claude/skills/memory/memory.py about "error handling"
+python3 ~/.claude/skills/memory/memory.py about "testing strategy"
+```
+
+### Preview session context
+
+```bash
+python3 ~/.claude/skills/memory/memory.py context [options]
+```
+
+Shows what context would be injected into a new session.
+
+Options:
+- `--project <path>` - Project path
+- `--limit <n>` - Max memories (default: 5)
+
+## Natural Language Patterns
+
+When users say things like:
+- "What did we decide about..." -> Use `search` or `decisions`
+- "Remember that we..." -> Use `store`
+- "What do you know about..." -> Use `about`
+- "Show recent context" -> Use `recent` or `context`
+- "Save this insight..." -> Use `store`
+
+## How Memory Works
+
+### Automatic Extraction
+Memories are automatically extracted from conversations:
+1. **PreCompact Hook** - Before context compaction, key insights are extracted
+2. **Stop Hook** - After Claude responds, important facts are saved asynchronously
+
+### Session Context
+When a new session starts, relevant memories are automatically injected based on:
+- Project path matching
+- Recency
+- Relevance score
+- Access frequency
+
+### Relevance Scoring
+Each memory has a relevance score (0-1):
+- Newly stored memories start at 0.9
+- Frequently accessed memories maintain higher scores
+- Old, unused memories gradually decay
+
+## Best Practices
+
+1. **Store key decisions** - When making architectural choices, use `store --type decision`
+2. **Check before changes** - Before major refactors, use `about` to check relevant history
+3. **Review decisions** - Use `decisions` to see past architectural choices
+4. **Explicit storage** - For critical insights, explicitly store rather than relying on auto-extraction

package/Claude/skills/memory/memory.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Memory Management Skill for Cognova
+
+Provides access to persistent memory across Claude sessions.
+
+Usage:
+    python memory.py search <query>
+    python memory.py recent [limit]
+    python memory.py store <content> [options]
+    python memory.py decisions
+    python memory.py about <topic>
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / '_lib'))
+
+from api import get, post
+from output import success, error, info
+
+
+def format_memory(memory: dict) -> str:
+    """Format a memory chunk for display."""
+    type_icons = {
+        'decision': '[D]',
+        'fact': '[F]',
+        'solution': '[S]',
+        'pattern': '[P]',
+        'preference': '[*]',
+        'summary': '[~]'
+    }
+
+    chunk_type = memory.get('chunkType', 'fact')
+    icon = type_icons.get(chunk_type, '[?]')
+    content = memory.get('content', '')
+    relevance = memory.get('relevanceScore', 1.0)
+
+    # First line: icon and content
+    line1 = f"{icon} {content}"
+
+    # Second line: metadata
+    parts = [f"ID: {memory['id'][:8]}"]
+
+    if memory.get('projectPath'):
+        parts.append(f"Project: {memory['projectPath']}")
+
+    parts.append(f"Relevance: {relevance:.2f}")
+
+    if memory.get('accessCount'):
+        parts.append(f"Accessed: {memory['accessCount']}x")
+
+    created = memory.get('createdAt', '')
+    if created:
+        parts.append(f"Created: {created[:10]}")
+
+    line2 = "    " + " | ".join(parts)
+
+    return f"{line1}\n{line2}"
+
+
+def cmd_search(args):
+    """Search memories by query."""
+    params = {
+        'query': args.query,
+        'limit': args.limit or 10
+    }
+
+    if args.type:
+        params['chunkType'] = args.type
+
+    if args.project:
+        params['projectPath'] = args.project
+
+    ok, memories = get('/memory/search', params)
+    if not ok:
+        error(f"Failed to search memories: {memories}")
+        sys.exit(1)
+
+    if not memories:
+        print(f"No memories found matching '{args.query}'")
+        return
+
+    print(f"Found {len(memories)} memory/memories:\n")
+    for memory in memories:
+        print(format_memory(memory))
+        print()
+
+
+def cmd_recent(args):
+    """Get recent memories."""
+    params = {
+        'limit': args.limit or 10
+    }
+
+    if args.type:
+        params['chunkType'] = args.type
+
+    ok, memories = get('/memory/search', params)
+    if not ok:
+        error(f"Failed to fetch recent memories: {memories}")
+        sys.exit(1)
+
+    if not memories:
+        print("No memories stored yet.")
+        return
+
+    print(f"Recent {len(memories)} memory/memories:\n")
+    for memory in memories:
+        print(format_memory(memory))
+        print()
+
+
+def cmd_store(args):
+    """Store a new memory explicitly."""
+    data = {
+        'content': args.content,
+        'chunkType': args.type or 'fact',
+        'relevanceScore': args.relevance or 0.9
+    }
+
+    if args.project:
+        data['projectPath'] = args.project
+
+    ok, result = post('/memory/store', data)
+    if ok:
+        success(f"Stored memory: {args.content[:50]}...")
+        print(f"\nID: {result['id'][:8]}")
+        print(f"Type: {result['chunkType']}")
+    else:
+        error(f"Failed to store memory: {result}")
+        sys.exit(1)
+
+
+def cmd_decisions(args):
+    """List all decision memories."""
+    params = {
+        'chunkType': 'decision',
+        'limit': args.limit or 20
+    }
+
+    if args.project:
+        params['projectPath'] = args.project
+
+    ok, memories = get('/memory/search', params)
+    if not ok:
+        error(f"Failed to fetch decisions: {memories}")
+        sys.exit(1)
+
+    if not memories:
+        print("No decisions recorded yet.")
+        return
+
+    print(f"Found {len(memories)} decision(s):\n")
+    for memory in memories:
+        print(format_memory(memory))
+        print()
+
+
+def cmd_about(args):
+    """Find memories about a specific topic."""
+    params = {
+        'query': args.topic,
+        'limit': args.limit or 15
+    }
+
+    ok, memories = get('/memory/search', params)
+    if not ok:
+        error(f"Failed to search memories: {memories}")
+        sys.exit(1)
+
+    if not memories:
+        print(f"No memories found about '{args.topic}'")
+        return
+
+    print(f"Memories about '{args.topic}':\n")
+    for memory in memories:
+        print(format_memory(memory))
+        print()
+
+
+def cmd_context(args):
+    """Get context that would be injected into a session."""
+    params = {
+        'limit': args.limit or 5
+    }
+
+    if args.project:
+        params['projectPath'] = args.project
+
+    ok, response = get('/memory/context', params)
+    if not ok:
+        error(f"Failed to fetch context: {response}")
+        sys.exit(1)
+
+    if not response.get('memories'):
+        print("No relevant context available.")
+        return
+
+    print("Context that would be injected:\n")
+    print("-" * 50)
+    print(response.get('formattedContext', ''))
+    print("-" * 50)
+    print(f"\n({len(response['memories'])} memories included)")
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Memory Management Skill')
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    # Search
+    search_p = subparsers.add_parser('search', help='Search memories')
+    search_p.add_argument('query', help='Search query')
+    search_p.add_argument('--type', '-t',
+                          choices=['decision', 'fact', 'solution', 'pattern', 'preference', 'summary'],
+                          help='Filter by memory type')
+    search_p.add_argument('--project', '-p', help='Filter by project path')
+    search_p.add_argument('--limit', '-l', type=int, default=10, help='Max results')
+
+    # Recent
+    recent_p = subparsers.add_parser('recent', help='Get recent memories')
+    recent_p.add_argument('limit', nargs='?', type=int, default=10, help='Number of memories')
+    recent_p.add_argument('--type', '-t',
+                          choices=['decision', 'fact', 'solution', 'pattern', 'preference', 'summary'],
+                          help='Filter by memory type')
+
+    # Store
+    store_p = subparsers.add_parser('store', help='Store a memory')
+    store_p.add_argument('content', help='Memory content')
+    store_p.add_argument('--type', '-t',
+                         choices=['decision', 'fact', 'solution', 'pattern', 'preference', 'summary'],
+                         default='fact',
+                         help='Memory type (default: fact)')
+    store_p.add_argument('--project', '-p', help='Associated project path')
+    store_p.add_argument('--relevance', '-r', type=float, default=0.9,
+                         help='Relevance score 0-1 (default: 0.9)')
+
+    # Decisions
+    decisions_p = subparsers.add_parser('decisions', help='List decision memories')
+    decisions_p.add_argument('--project', '-p', help='Filter by project')
+    decisions_p.add_argument('--limit', '-l', type=int, default=20, help='Max results')
+
+    # About
+    about_p = subparsers.add_parser('about', help='Find memories about a topic')
+    about_p.add_argument('topic', help='Topic to search for')
+    about_p.add_argument('--limit', '-l', type=int, default=15, help='Max results')
+
+    # Context
+    context_p = subparsers.add_parser('context', help='Preview session context')
+    context_p.add_argument('--project', '-p', help='Project path')
+    context_p.add_argument('--limit', '-l', type=int, default=5, help='Max memories')
+
+    args = parser.parse_args()
+
+    commands = {
+        'search': cmd_search,
+        'recent': cmd_recent,
+        'store': cmd_store,
+        'decisions': cmd_decisions,
+        'about': cmd_about,
+        'context': cmd_context,
+    }
+
+    commands[args.command](args)
+
+
+if __name__ == '__main__':
+    main()