knight-os 0.1.0

package/scripts/reflection-analyzer.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""
+reflection-analyzer.py — Analyze reflections for repeated failure patterns.
+
+Usage:
+  python3 scripts/reflection-analyzer.py             # Incremental analysis
+  python3 scripts/reflection-analyzer.py --dry-run   # Print only, no side effects
+  python3 scripts/reflection-analyzer.py --all       # Full analysis (ignore cursor)
+  python3 scripts/reflection-analyzer.py --min-count 3  # Adjust threshold (default: 2)
+
+Backends:
+  - local (default): reads from {workspace}/memory/reflections/*.jsonl
+  - supabase: queries Supabase REST API (requires config)
+"""
+
+import json
+import os
+import sys
+import argparse
+import re
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+from collections import defaultdict
+from typing import Optional
+
+
+PATTERN_MAP = [
+    {
+        "id": "db-schema-assumption",
+        "label": "Database field assumption",
+        "keywords": ["column", "schema", "field", "table", "mapping"],
+        "rule": "Verify schema before any DB operation: `SELECT column_name FROM information_schema.columns WHERE table_name='xxx'`",
+    },
+    {
+        "id": "task-status-not-updated",
+        "label": "Task status not updated after completion",
+        "keywords": ["PATCH", "status", "not updated", "backlog", "task status"],
+        "rule": "After task completion, always: write-reflection + update status — both steps must complete together",
+    },
+    {
+        "id": "missing-reflection",
+        "label": "Forgot to write reflection",
+        "keywords": ["reflection", "forgot", "missing", "not written"],
+        "rule": "No reflection = task not complete. Always call write-reflection.py immediately after finishing a task",
+    },
+    {
+        "id": "heartbeat-gap",
+        "label": "Heartbeat gap/interruption",
+        "keywords": ["gap", "interrupted", "blank", "no record", "heartbeat"],
+        "rule": "After a heartbeat gap, explain the reason on next execution. 2+ consecutive gaps require user notification",
+    },
+    {
+        "id": "silent-tool-switch",
+        "label": "Silent tool switch after failure",
+        "keywords": ["silent", "tool failed", "unreported", "switch"],
+        "rule": "When a tool fails, always report: 'X failed, switching to Y' — silence is a violation",
+    },
+    {
+        "id": "read-before-exec",
+        "label": "Modify without reading first",
+        "keywords": ["read", "file", "confirm", "structure", "before modify"],
+        "rule": "Before modifying any file: read first, understand structure, then execute",
+    },
+    {
+        "id": "rule-exists-not-executed",
+        "label": "Rule exists but not followed",
+        "keywords": ["rule exists", "known but", "not executed", "upgrade"],
+        "rule": "When a rule exists but wasn't followed, escalate its priority to mandatory trigger",
+    },
+    {
+        "id": "blocked-task-not-surfaced",
+        "label": "Blocked task not surfaced",
+        "keywords": ["blocked", "waiting", "needs confirmation", "cannot close"],
+        "rule": "Blocked tasks must be surfaced every heartbeat — never let them accumulate silently",
+    },
+]
+
+
+def load_config():
+    config_paths = [
+        Path.cwd() / "knight.config.json",
+        Path.home() / ".knight" / "config.json",
+    ]
+    for p in config_paths:
+        if p.exists():
+            try:
+                return json.loads(p.read_text())
+            except (json.JSONDecodeError, OSError):
+                pass
+    return {}
+
+
+def resolve_workspace(config):
+    ws = config.get("workspace", "~/.openclaw/workspace")
+    return Path(ws).expanduser()
+
+
+def get_cursor_path(config):
+    workspace = resolve_workspace(config)
+    return workspace / ".knight-reflection-cursor"
+
+
+def read_cursor(config) -> Optional[str]:
+    cursor_file = get_cursor_path(config)
+    if cursor_file.exists():
+        return cursor_file.read_text().strip() or None
+    return None
+
+
+def write_cursor(config, ts: str):
+    cursor_file = get_cursor_path(config)
+    cursor_file.write_text(ts)
+
+
+def fetch_local(config, since: Optional[str]) -> list:
+    """Read reflections from local .jsonl files."""
+    workspace = resolve_workspace(config)
+    local_cfg = config.get("storage", {}).get("local", {})
+    reflections_dir = workspace / local_cfg.get("reflections_dir", "memory/reflections")
+
+    if not reflections_dir.exists():
+        return []
+
+    rows = []
+    for jsonl_file in sorted(reflections_dir.glob("*.jsonl")):
+        with open(jsonl_file, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    row = json.loads(line)
+                    if since and row.get("created_at", "") <= since:
+                        continue
+                    rows.append(row)
+                except json.JSONDecodeError:
+                    continue
+    return rows
+
+
+def fetch_supabase(config, since: Optional[str]) -> list:
+    """Fetch reflections from Supabase REST API."""
+    supabase_cfg = config.get("storage", {}).get("supabase", {})
+    url = supabase_cfg.get("url", "")
+    key = supabase_cfg.get("service_key", "") or os.environ.get("SUPABASE_SERVICE_KEY", "")
+
+    if not url or not key:
+        print("Error: Supabase URL or key not configured.", file=sys.stderr)
+        sys.exit(1)
+
+    params = "select=id,created_at,context,what_failed,next_time,confidence&order=created_at.asc&limit=200"
+    if since:
+        ts = since.replace("+", "%2B").replace(":", "%3A")
+        params += f"&created_at=gt.{ts}"
+
+    req = urllib.request.Request(
+        f"{url}/rest/v1/reflections?{params}",
+        headers={"apikey": key, "Authorization": f"Bearer {key}"},
+        method="GET",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as r:
+            return json.load(r)
+    except Exception as e:
+        print(f"Error: Supabase query failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def analyze(rows: list, min_count: int) -> list:
+    hits = defaultdict(list)
+
+    for row in rows:
+        text = " ".join([
+            row.get("what_failed") or "",
+            row.get("next_time") or "",
+            row.get("context") or "",
+        ]).lower()
+
+        for p in PATTERN_MAP:
+            for kw in p["keywords"]:
+                if re.search(kw.lower(), text):
+                    hits[p["id"]].append(row)
+                    break
+
+    candidates = []
+    for p in PATTERN_MAP:
+        matched = hits[p["id"]]
+        if len(matched) >= min_count:
+            candidates.append({
+                "pattern": p,
+                "count": len(matched),
+                "examples": matched[:2],
+            })
+
+    candidates.sort(key=lambda x: -x["count"])
+    return candidates
+
+
+def format_console(candidates: list, rows: list, since: Optional[str]) -> str:
+    scope = f"since {since[:10]}" if since else "all data"
+    lines = [f"\n[knight] Reflection Analyzer | {scope} | {len(rows)} entries"]
+
+    if not candidates:
+        lines.append("  No repeated failure patterns found — system stable")
+    else:
+        lines.append(f"  Found {len(candidates)} candidate rules:\n")
+        for i, c in enumerate(candidates, 1):
+            p = c["pattern"]
+            lines.append(f"  [{i}] {p['label']} x {c['count']} times")
+            lines.append(f"      Rule: {p['rule']}")
+            for ex in c["examples"]:
+                snippet = (ex.get("what_failed") or "")[:60]
+                lines.append(f"      Example: \"{snippet}...\"")
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def format_notification(candidates: list, rows: list, since: Optional[str], config: dict) -> Optional[str]:
+    if not candidates:
+        return None
+
+    user_name = config.get("user_name", "User")
+    scope = f"since {since[:10]}" if since else "all data"
+    lines = [
+        f"[knight] Reflection Analysis | {scope} | {len(rows)} entries",
+        f"Found {len(candidates)} repeated failure patterns — suggest writing to ai-patterns.md\n",
+    ]
+
+    for i, c in enumerate(candidates, 1):
+        p = c["pattern"]
+        lines.append(f"{i}. {p['label']} x {c['count']} times")
+        lines.append(f"   Rule: {p['rule']}")
+        ex = c["examples"][0]
+        snippet = (ex.get("what_failed") or "")[:50]
+        lines.append(f"   Recent: \"{snippet}\"\n")
+
+    lines.append(f"Reply 'write' to add to ai-patterns.md / 'skip' to ignore")
+    return "\n".join(lines)
+
+
+def send_telegram(text: str, config: dict):
+    telegram_cfg = config.get("notifications", {}).get("telegram", {})
+    bot_token = telegram_cfg.get("bot_token", "") or os.environ.get("TELEGRAM_BOT_TOKEN", "")
+    chat_id = telegram_cfg.get("chat_id", "") or os.environ.get("TELEGRAM_CHAT_ID", "")
+
+    if not bot_token or not chat_id:
+        print("  Warning: Telegram not configured, skipping notification", file=sys.stderr)
+        return
+
+    payload = {"chat_id": chat_id, "text": text}
+    req = urllib.request.Request(
+        f"https://api.telegram.org/bot{bot_token}/sendMessage",
+        data=json.dumps(payload).encode(),
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            resp = json.load(r)
+            if resp.get("ok"):
+                print("  Telegram notification sent")
+            else:
+                print(f"  Telegram failed: {resp}", file=sys.stderr)
+    except Exception as e:
+        print(f"  Telegram error: {e}", file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze reflections for repeated failure patterns.")
+    parser.add_argument("--dry-run", action="store_true", help="Print only, no side effects")
+    parser.add_argument("--all", action="store_true", help="Analyze all data (ignore cursor)")
+    parser.add_argument("--min-count", type=int, default=2, help="Trigger threshold (default: 2)")
+    args = parser.parse_args()
+
+    config = load_config()
+    min_count = config.get("reflection", {}).get("min_pattern_count", args.min_count)
+    if args.min_count != 2:
+        min_count = args.min_count
+
+    since = None if args.all else read_cursor(config)
+    scope_desc = "all data" if not since else f"since {since[:10]}"
+    print(f"[knight] Analysis scope: {scope_desc}")
+
+    storage_cfg = config.get("storage", {})
+    backend = storage_cfg.get("backend", "local")
+
+    if backend == "supabase" or storage_cfg.get("supabase", {}).get("enabled"):
+        rows = fetch_supabase(config, since)
+    else:
+        rows = fetch_local(config, since)
+
+    print(f"  Read {len(rows)} reflections")
+
+    if not rows:
+        print("  No new data, skipping analysis")
+        return
+
+    candidates = analyze(rows, min_count)
+    print(format_console(candidates, rows, since))
+
+    latest_ts = rows[-1].get("created_at", datetime.now(timezone.utc).isoformat())
+    if not args.dry_run:
+        write_cursor(config, latest_ts)
+        print(f"  Cursor updated to {latest_ts[:16]}")
+
+    if candidates and not args.dry_run:
+        notifications_cfg = config.get("notifications", {})
+        if notifications_cfg.get("telegram", {}).get("enabled"):
+            msg = format_notification(candidates, rows, since, config)
+            if msg:
+                send_telegram(msg, config)
+    elif args.dry_run:
+        print("\n  [dry-run: no cursor update, no notifications]")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/write-reflection.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+write-reflection.py — Write a reflection after task completion.
+
+Usage:
+  python3 scripts/write-reflection.py \
+    --context "Task title" \
+    --what_worked "What went well" \
+    --what_failed "What did not work" \
+    --next_time "How to improve" \
+    --tags "execution,memory" \
+    --session_type "heartbeat" \
+    --confidence 3
+
+Storage backends:
+  - local (default): appends JSON to {workspace}/memory/reflections/YYYY-MM-DD.jsonl
+  - supabase: POST to Supabase REST API (requires storage.supabase.enabled=true in config)
+"""
+
+import json
+import os
+import sys
+import argparse
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def load_config():
+    """Load knight config from project or global path."""
+    config_paths = [
+        Path.cwd() / "knight.config.json",
+        Path.home() / ".knight" / "config.json",
+    ]
+    for p in config_paths:
+        if p.exists():
+            try:
+                return json.loads(p.read_text())
+            except (json.JSONDecodeError, OSError) as e:
+                print(f"Warning: failed to read {p}: {e}", file=sys.stderr)
+    return {}
+
+
+def resolve_workspace(config):
+    ws = config.get("workspace", "~/.openclaw/workspace")
+    return Path(ws).expanduser()
+
+
+def write_local(payload, config):
+    """Write reflection as a JSON line to local file."""
+    workspace = resolve_workspace(config)
+    local_cfg = config.get("storage", {}).get("local", {})
+    reflections_dir = workspace / local_cfg.get("reflections_dir", "memory/reflections")
+    reflections_dir.mkdir(parents=True, exist_ok=True)
+
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    filepath = reflections_dir / f"{today}.jsonl"
+
+    with open(filepath, "a", encoding="utf-8") as f:
+        f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    print(f"[knight] reflection written to {filepath}")
+
+
+def write_supabase(payload, config):
+    """Write reflection to Supabase REST API."""
+    import urllib.request
+
+    supabase_cfg = config.get("storage", {}).get("supabase", {})
+    url = supabase_cfg.get("url", "")
+    key = supabase_cfg.get("service_key", "") or os.environ.get("SUPABASE_SERVICE_KEY", "")
+
+    if not url or not key:
+        print("Error: Supabase URL or service key not configured.", file=sys.stderr)
+        sys.exit(1)
+
+    req = urllib.request.Request(
+        f"{url}/rest/v1/reflections",
+        data=json.dumps(payload).encode(),
+        headers={
+            "apikey": key,
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "Prefer": "return=representation",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as r:
+            d = json.load(r)
+            print(f"[knight] reflection written to Supabase: {d[0]['id'][:8]}...")
+    except Exception as e:
+        print(f"Error: Supabase write failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Write a reflection after task completion.")
+    parser.add_argument("--context", required=True, help="Task context or title")
+    parser.add_argument("--what_worked", default="", help="What went well")
+    parser.add_argument("--what_failed", default="", help="What did not work")
+    parser.add_argument("--next_time", default="", help="Improvement for next time")
+    parser.add_argument("--tags", default="execution", help="Comma-separated tags")
+    parser.add_argument("--session_type", default="heartbeat", help="Session type")
+    parser.add_argument("--confidence", type=int, default=3, help="Confidence 1-5")
+    parser.add_argument("--task_type", default="", help="Task type")
+    args = parser.parse_args()
+
+    config = load_config()
+
+    payload = {
+        "context": args.context,
+        "what_worked": args.what_worked,
+        "what_failed": args.what_failed,
+        "next_time": args.next_time,
+        "tags": [t.strip() for t in args.tags.split(",") if t.strip()],
+        "session_type": args.session_type,
+        "confidence": args.confidence,
+        "task_type": args.task_type,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    storage_cfg = config.get("storage", {})
+    backend = storage_cfg.get("backend", "local")
+
+    if backend == "supabase" or storage_cfg.get("supabase", {}).get("enabled"):
+        write_supabase(payload, config)
+    else:
+        write_local(payload, config)
+
+
+if __name__ == "__main__":
+    main()

package/src/chat.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const readline = require('readline');
+
+function loadEnv(workspace) {
+  const envPath = path.join(workspace, '.env');
+  const vars = {};
+  if (!fs.existsSync(envPath)) return vars;
+  const content = fs.readFileSync(envPath, 'utf-8');
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx === -1) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const val = trimmed.slice(idx + 1).trim();
+    vars[key] = val;
+  }
+  return vars;
+}
+
+function loadSystemPrompt(workspace, config) {
+  const files = (config.model && config.model.system_prompt_files) || [
+    'SOUL.md',
+    'AGENTS.md',
+    'MEMORY.md',
+    'REDLINES.md',
+  ];
+  const loaded = [];
+  const parts = [];
+
+  for (const file of files) {
+    const filePath = path.join(workspace, file);
+    if (!fs.existsSync(filePath)) continue;
+    const content = fs.readFileSync(filePath, 'utf-8').trim();
+    if (!content) continue;
+    parts.push(`<!-- ${file} -->\n${content}`);
+    loaded.push(file);
+  }
+
+  return { systemPrompt: parts.join('\n\n'), loadedFiles: loaded };
+}
+
+function callAnthropic(apiKey, model, messages, systemPrompt, maxTokens, onChunk) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      system: systemPrompt,
+      messages,
+      stream: true,
+    });
+
+    const options = {
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+    };
+
+    const req = https.request(options, (res) => {
+      if (res.statusCode === 401) {
+        reject(new Error('Invalid API key. Check your ANTHROPIC_API_KEY.'));
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        let data = '';
+        res.on('data', (chunk) => (data += chunk));
+        res.on('end', () => {
+          try {
+            const err = JSON.parse(data);
+            reject(
+              new Error(
+                `API error (${err.error?.type || res.statusCode}): ${err.error?.message || data}`
+              )
+            );
+          } catch {
+            reject(new Error(`API error (${res.statusCode}): ${data}`));
+          }
+        });
+        return;
+      }
+
+      let buffer = '';
+      let fullText = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue;
+          const payload = line.slice(6).trim();
+          if (payload === '[DONE]') continue;
+          try {
+            const event = JSON.parse(payload);
+            if (
+              event.type === 'content_block_delta' &&
+              event.delta?.type === 'text_delta'
+            ) {
+              const text = event.delta.text;
+              fullText += text;
+              onChunk(text);
+            }
+          } catch {
+            // skip malformed events
+          }
+        }
+      });
+
+      res.on('end', () => resolve(fullText));
+    });
+
+    req.on('error', (err) => reject(new Error(`Network error: ${err.message}`)));
+    req.write(body);
+    req.end();
+  });
+}
+
+async function chat(config, workspace) {
+  const model = (config.model && config.model.name) || 'claude-sonnet-4-5';
+  const maxTokens = (config.model && config.model.max_tokens) || 8096;
+
+  const env = loadEnv(workspace);
+  const apiKey = env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+
+  if (!apiKey) {
+    console.log('\nNo Anthropic API key found.');
+    console.log(
+      'Run `knight init` to configure, or set ANTHROPIC_API_KEY in your workspace .env file.\n'
+    );
+    process.exit(1);
+  }
+
+  const { systemPrompt, loadedFiles } = loadSystemPrompt(workspace, config);
+
+  const separator = '──────────────────────────────────────────────────────';
+
+  console.log(`\nKnight Chat — ${model}`);
+  if (loadedFiles.length > 0) {
+    console.log(
+      `System prompt loaded from: ${loadedFiles.join(', ')} (${loadedFiles.length} files)`
+    );
+  } else {
+    console.log('System prompt: (no files found)');
+  }
+  console.log('Type /exit or Ctrl+C to quit, /clear to reset history, /memory to view system prompt');
+  console.log(separator);
+
+  const messages = [];
+  let turns = 0;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const askUser = () => {
+    return new Promise((resolve) => {
+      rl.question('\nYou: ', (answer) => resolve(answer));
+    });
+  };
+
+  const shutdown = () => {
+    console.log(`\nGoodbye. Conversation had ${turns} turns.`);
+    rl.close();
+    process.exit(0);
+  };
+
+  rl.on('close', shutdown);
+
+  while (true) {
+    const input = await askUser();
+    if (input === null || input === undefined) break;
+
+    const trimmed = input.trim();
+    if (!trimmed) continue;
+
+    if (trimmed === '/exit') {
+      console.log(`\nGoodbye. Conversation had ${turns} turns.`);
+      rl.close();
+      process.exit(0);
+    }
+
+    if (trimmed === '/clear') {
+      messages.length = 0;
+      turns = 0;
+      console.log('History cleared.');
+      continue;
+    }
+
+    if (trimmed === '/memory') {
+      console.log(`\n${separator}`);
+      console.log(systemPrompt || '(empty system prompt)');
+      console.log(separator);
+      continue;
+    }
+
+    if (trimmed === '/help') {
+      console.log('\nCommands:');
+      console.log('  /exit   — Exit chat');
+      console.log('  /clear  — Clear conversation history');
+      console.log('  /memory — Show system prompt');
+      console.log('  /help   — Show this help');
+      continue;
+    }
+
+    messages.push({ role: 'user', content: trimmed });
+
+    process.stdout.write('\nAssistant: ');
+
+    try {
+      const reply = await callAnthropic(apiKey, model, messages, systemPrompt, maxTokens, (chunk) => {
+        process.stdout.write(chunk);
+      });
+      process.stdout.write('\n');
+      messages.push({ role: 'assistant', content: reply });
+      turns++;
+    } catch (err) {
+      process.stdout.write('\n');
+      console.log(`Error: ${err.message}`);
+    }
+
+    console.log(separator);
+  }
+}
+
+module.exports = { chat, loadEnv, loadSystemPrompt, callAnthropic };