create-yonderclaw 1.0.0

package/installer/templates/self-update.ts.txt

@@ -0,0 +1,345 @@
+/**
+ * Self-Update Module — keeps the agent's knowledge and config current
+ * Auto-generated by MetaClaw Installer v3.3.0
+ *
+ * Responsibilities:
+ * 1. Periodic memory consolidation (update CLAUDE.md, SOUL.md with learnings)
+ * 2. Prompt optimization (Generator→Reflector→Curator loop)
+ * 3. Metrics rollup and reporting
+ * 4. Detect when context is getting stale and trigger refresh
+ * 5. Log rotation and cleanup
+ *
+ * Schedule: configurable via config table (default: every 6 hours)
+ */
+
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import type { SDKResultMessage, SDKResultSuccess } from "@anthropic-ai/claude-agent-sdk";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { getDb, getConfig, setConfig, getTodayMetrics, recordAction } from "./db.js";
+import { log } from "./observability.js";
+import { getCurrentPrompt, savePromptVersion, shouldOptimize } from "./self-improve.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_DIR = path.join(__dirname, "..");
+
+// Default update interval: 6 hours (in milliseconds)
+const DEFAULT_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+
+/**
+ * Check if a self-update cycle is due and run it if so.
+ * Called at the start of every agent run.
+ */
+export async function runSelfUpdate(): Promise<void> {
+  const db = getDb();
+  const lastUpdate = getConfig("last_self_update");
+  const intervalMs = parseInt(getConfig("self_update_interval_ms") || String(DEFAULT_UPDATE_INTERVAL_MS));
+
+  if (lastUpdate) {
+    const elapsed = Date.now() - new Date(lastUpdate).getTime();
+    if (elapsed < intervalMs) {
+      return; // Not due yet
+    }
+  }
+
+  log("info", "self_update.start", {});
+  console.log("[Self-Update] Running periodic maintenance...");
+
+  try {
+    // 1. Regenerate dashboard data
+    regenerateDashboard();
+
+    // 2. Consolidate metrics into CLAUDE.md
+    await updateClaudeMd();
+
+    // 3. Run prompt optimization if enough data
+    await optimizePrompts();
+
+    // 4. Rotate old logs
+    rotateOldLogs();
+
+    // 5. Update heartbeat
+    updateHeartbeat();
+
+    // 6. Update SESSION.md with current state
+    updateSessionState();
+
+    // Record completion
+    setConfig("last_self_update", new Date().toISOString());
+    log("info", "self_update.complete", {});
+    console.log("[Self-Update] Complete.");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log("error", "self_update.failed", { error: msg });
+    console.error("[Self-Update] Failed: " + msg);
+  }
+}
+
+/**
+ * Update CLAUDE.md with latest metrics and learnings.
+ */
+async function updateClaudeMd(): Promise<void> {
+  const claudeMdPath = path.join(PROJECT_DIR, "CLAUDE.md");
+  if (!fs.existsSync(claudeMdPath)) return;
+
+  const currentContent = fs.readFileSync(claudeMdPath, "utf-8");
+
+  // Gather metrics from last 7 days
+  const db = getDb();
+  const weekMetrics = db.prepare(`
+    SELECT
+      SUM(actions_taken) as total_actions,
+      SUM(actions_succeeded) as total_succeeded,
+      SUM(actions_failed) as total_failed,
+      SUM(total_cost_usd) as total_cost,
+      COUNT(*) as days_active
+    FROM daily_metrics
+    WHERE date > date('now', '-7 days')
+  `).get() as any;
+
+  // Get prompt performance
+  const promptStats = db.prepare(`
+    SELECT prompt_type, version, avg_score, total_runs
+    FROM prompt_versions
+    WHERE is_active = 1
+    ORDER BY prompt_type
+  `).all() as any[];
+
+  // Build the metrics section
+  const metricsSection = [
+    "",
+    "## Latest Metrics (auto-updated)",
+    "Last updated: " + new Date().toISOString().slice(0, 16),
+    "",
+    weekMetrics ? [
+      "### Last 7 Days",
+      "- Actions: " + (weekMetrics.total_actions || 0),
+      "- Success rate: " + (weekMetrics.total_actions > 0 ? ((weekMetrics.total_succeeded / weekMetrics.total_actions) * 100).toFixed(1) + "%" : "N/A"),
+      "- Cost: $" + (weekMetrics.total_cost || 0).toFixed(2),
+      "- Days active: " + (weekMetrics.days_active || 0),
+    ].join("\n") : "No metrics yet.",
+    "",
+    promptStats.length > 0 ? [
+      "### Prompt Performance",
+      ...promptStats.map((p: any) => "- " + p.prompt_type + " v" + p.version + ": avg " + (p.avg_score || 0).toFixed(1) + "/10 (" + p.total_runs + " runs)"),
+    ].join("\n") : "",
+  ].join("\n");
+
+  // Replace or append metrics section
+  const metricsMarker = "## Latest Metrics (auto-updated)";
+  if (currentContent.includes(metricsMarker)) {
+    // Replace existing metrics section (from marker to next ## or end)
+    const before = currentContent.split(metricsMarker)[0];
+    const afterMatch = currentContent.split(metricsMarker)[1]?.match(/\n## [^L]/);
+    const after = afterMatch ? currentContent.split(metricsMarker)[1].slice(afterMatch.index!) : "";
+    fs.writeFileSync(claudeMdPath, before + metricsSection + after);
+  } else {
+    // Append
+    fs.writeFileSync(claudeMdPath, currentContent + "\n" + metricsSection);
+  }
+
+  log("info", "self_update.claude_md_updated", {});
+}
+
+/**
+ * Run the Curator — optimize prompts based on performance data.
+ * Only runs when shouldOptimize() returns true (every 30 runs).
+ */
+async function optimizePrompts(): Promise<void> {
+  const db = getDb();
+
+  // Get all prompt types that need optimization
+  const promptTypes = db.prepare(
+    "SELECT DISTINCT prompt_type FROM prompt_versions WHERE is_active = 1"
+  ).all() as any[];
+
+  for (const { prompt_type } of promptTypes) {
+    if (!shouldOptimize(prompt_type)) continue;
+
+    const current = getCurrentPrompt(prompt_type);
+    if (!current) continue;
+
+    // Get recent performance data
+    const recentActions = db.prepare(`
+      SELECT status, details, cost_usd
+      FROM action_log
+      WHERE action_type LIKE '%${prompt_type}%'
+      ORDER BY created_at DESC
+      LIMIT 50
+    `).all() as any[];
+
+    const successRate = recentActions.length > 0
+      ? recentActions.filter((a: any) => a.status === "success").length / recentActions.length
+      : 0;
+
+    // Only optimize if success rate is below 90%
+    if (successRate > 0.9) {
+      log("info", "self_update.skip_optimize", { prompt_type, successRate });
+      continue;
+    }
+
+    log("info", "self_update.optimizing_prompt", { prompt_type, successRate });
+
+    try {
+      // Ask Claude to improve the prompt
+      const optimizePrompt = [
+        "You are a prompt optimization expert. Analyze this prompt and its performance data, then produce an improved version.",
+        "",
+        "CURRENT PROMPT:",
+        current,
+        "",
+        "PERFORMANCE DATA:",
+        "- Success rate: " + (successRate * 100).toFixed(1) + "%",
+        "- Total recent runs: " + recentActions.length,
+        "- Common failure details: " + recentActions.filter((a: any) => a.status === "error").map((a: any) => a.details).filter(Boolean).slice(0, 5).join("; "),
+        "",
+        "RULES:",
+        "- Change ONE thing at a time (so we can measure impact)",
+        "- Keep the same structure and format",
+        "- Focus on the biggest failure mode",
+        "- The improved prompt must be directly usable (no meta-commentary)",
+        "",
+        "Output ONLY the improved prompt text. Nothing else.",
+      ].join("\n");
+
+      let improvedPrompt = "";
+      const stream = query({
+        prompt: optimizePrompt,
+        options: { allowedTools: [], maxTurns: 1, model: "claude-sonnet-4-6" },
+      });
+
+      for await (const message of stream) {
+        if (message.type === "assistant") {
+          const msg = message as any;
+          if (msg.message?.content) {
+            for (const block of msg.message.content) {
+              if (block.type === "text") improvedPrompt += block.text;
+            }
+          }
+        }
+      }
+
+      if (improvedPrompt.trim()) {
+        savePromptVersion(prompt_type, improvedPrompt.trim(), "curator");
+        log("info", "self_update.prompt_optimized", { prompt_type });
+      }
+    } catch (err) {
+      log("error", "self_update.optimize_failed", { prompt_type, error: String(err) });
+    }
+  }
+}
+
+/**
+ * Rotate logs older than 30 days.
+ */
+function rotateOldLogs(): void {
+  const logsDir = path.join(PROJECT_DIR, "data", "logs");
+  if (!fs.existsSync(logsDir)) return;
+
+  const thirtyDaysAgo = new Date();
+  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+  const files = fs.readdirSync(logsDir);
+  let rotated = 0;
+
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) continue;
+    const filePath = path.join(logsDir, file);
+    const stats = fs.statSync(filePath);
+    if (stats.mtime < thirtyDaysAgo) {
+      fs.unlinkSync(filePath);
+      rotated++;
+    }
+  }
+
+  if (rotated > 0) {
+    log("info", "self_update.logs_rotated", { count: rotated });
+  }
+}
+
+/**
+ * Update HEARTBEAT.md with last run timestamp.
+ */
+function updateHeartbeat(): void {
+  const heartbeatPath = path.join(PROJECT_DIR, "HEARTBEAT.md");
+  if (!fs.existsSync(heartbeatPath)) return;
+
+  let content = fs.readFileSync(heartbeatPath, "utf-8");
+  const now = new Date().toISOString().slice(0, 16);
+
+  if (content.includes("Last run:")) {
+    content = content.replace(/Last run:.*/, "Last run: " + now);
+  } else {
+    content += "\nLast run: " + now;
+  }
+
+  fs.writeFileSync(heartbeatPath, content);
+}
+
+/**
+ * Regenerate dashboard.json for the HTML dashboard.
+ */
+function regenerateDashboard(): void {
+  try {
+    const { execSync } = require("child_process");
+    execSync("npx tsx src/update-dashboard.ts", { cwd: PROJECT_DIR, stdio: "pipe", timeout: 15000 });
+    log("info", "self_update.dashboard_regenerated", {});
+  } catch {
+    // Non-critical — dashboard will update on next manual run
+  }
+}
+
+/**
+ * Update SESSION.md with current agent state.
+ */
+function updateSessionState(): void {
+  const sessionPath = path.join(PROJECT_DIR, "SESSION.md");
+  const db = getDb();
+  const now = new Date().toISOString().slice(0, 16);
+
+  const metrics = db.prepare("SELECT * FROM daily_metrics ORDER BY date DESC LIMIT 7").all() as any[];
+  const totalActions = metrics.reduce((s: number, m: any) => s + (m.actions_taken || 0), 0);
+  const totalCost = metrics.reduce((s: number, m: any) => s + (m.total_cost_usd || 0), 0);
+  const breaker = db.prepare("SELECT state, reason FROM circuit_breaker WHERE name = 'main'").get() as any;
+
+  const promptInfo = db.prepare(
+    "SELECT version, avg_score, total_runs FROM prompt_versions WHERE is_active = 1 ORDER BY version DESC LIMIT 1"
+  ).get() as any;
+
+  const content = [
+    "# Agent Session State",
+    "> Auto-updated: " + now,
+    "",
+    "## Health",
+    "- Circuit breaker: " + (breaker?.state || "closed").toUpperCase(),
+    breaker?.reason ? "- Reason: " + breaker.reason : "",
+    "",
+    "## Last 7 Days",
+    "- Total actions: " + totalActions,
+    "- Total cost: $" + totalCost.toFixed(2),
+    ...metrics.map((m: any) => "- " + m.date + ": " + m.actions_taken + " actions, $" + (m.total_cost_usd || 0).toFixed(4)),
+    "",
+    "## Self-Improvement",
+    promptInfo ? "- Current prompt: v" + promptInfo.version + " (avg score: " + (promptInfo.avg_score || 0).toFixed(1) + "/10, " + promptInfo.total_runs + " runs)" : "- Prompt: v1 (default)",
+    "- Next optimization: run #" + (promptInfo ? Math.ceil((promptInfo.total_runs + 1) / 30) * 30 : 30),
+  ].filter(Boolean).join("\n");
+
+  fs.writeFileSync(sessionPath, content);
+  log("info", "self_update.session_updated", {});
+}
+
+/**
+ * Force a self-update cycle (for manual trigger).
+ */
+export async function forceSelfUpdate(): Promise<void> {
+  setConfig("last_self_update", "2000-01-01T00:00:00Z");
+  await runSelfUpdate();
+}
+
+// --- CLI Entry Point ---
+if (process.argv[1]?.includes("self-update")) {
+  getDb();
+  console.log("Forcing self-update cycle...\n");
+  forceSelfUpdate().then(() => process.exit(0));
+}

package/installer/templates/state.json.txt

@@ -0,0 +1,33 @@
+{
+  "version": "1.0.0",
+  "initialized_at": "__TIMESTAMP__",
+  "days_operational": 0,
+  "agent_name": "__AGENT_NAME__",
+  "template": "__CLAW_TYPE__",
+  "operator": "",
+
+  "metrics": {
+    "sessions_completed": 0,
+    "tasks_completed": 0,
+    "tasks_failed": 0,
+    "error_rate": 0
+  },
+
+  "platforms": {},
+
+  "active_strategies": [],
+  "killed_strategies": [],
+
+  "current_focus": "Initial setup — read CLAUDE.md and SOUL.md",
+  "next_priority_action": "Run npm run status to verify systems, then introduce yourself to operator",
+
+  "system_context": {
+    "what_works": [],
+    "what_doesnt_work": [],
+    "core_rules": [],
+    "top_issues": [],
+    "last_self_eval": null
+  },
+
+  "session_notes": []
+}

package/installer/templates/system-context.json.txt

@@ -0,0 +1,33 @@
+{
+  "lastUpdated": "__TIMESTAMP__",
+
+  "campaignStats": {
+    "totalActions": 0,
+    "totalSucceeded": 0,
+    "totalFailed": 0,
+    "successRate": "0%"
+  },
+
+  "coreRules": [
+    "Read state.json at the START of every session",
+    "Update state.json at the END of every session",
+    "Self-update runs AFTER tasks, never before",
+    "Never create one-off scripts — use existing tools",
+    "Produce at least 1 tangible output per cycle"
+  ],
+
+  "whatWorks": [],
+  "whatDoesntWork": [],
+
+  "topObjections": [],
+
+  "latestStrategyInsight": "",
+
+  "processNotes": [
+    "Cron agent needs SPECIFIC numbered instructions — not goals",
+    "Email > Dashboard for operator communication",
+    "next_priority_action in state.json bridges main session and cron agent"
+  ],
+
+  "lastSelfEval": null
+}

package/installer/templates/update-dashboard.ts.txt

@@ -0,0 +1,126 @@
+/**
+ * Dashboard Data Generator — universal for all Claws
+ * Reads all DB tables and writes dashboard.json for the HTML dashboard.
+ * Auto-generated by MetaClaw Installer v3.3.0
+ *
+ * Run: npm run dashboard
+ * Also called by self-update module automatically.
+ */
+
+import Database from "better-sqlite3";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DB_PATH = path.join(__dirname, "..", "data", "claw.db");
+const LOG_DIR = path.join(__dirname, "..", "data", "logs");
+const OUTPUT = path.join(__dirname, "..", "data", "dashboard.json");
+
+function main() {
+  if (!fs.existsSync(DB_PATH)) {
+    console.log("No database found. Run the agent first.");
+    return;
+  }
+
+  const db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+
+  const now = new Date();
+  const today = now.toISOString().slice(0, 10);
+
+  // Today's metrics
+  const todayMetrics = db.prepare("SELECT * FROM daily_metrics WHERE date = ?").get(today) as any || {
+    actions_taken: 0, actions_succeeded: 0, actions_failed: 0, total_cost_usd: 0, total_tokens: 0
+  };
+
+  // Circuit breaker
+  const circuitBreaker = db.prepare("SELECT * FROM circuit_breaker WHERE name = 'main'").get() as any || { state: 'closed' };
+
+  // Safety config (from config table)
+  let safetyConfig = { maxActionsPerDay: 50, maxActionsPerHour: 10 };
+  try {
+    const raw = db.prepare("SELECT value FROM config WHERE key = 'safety_config'").get() as any;
+    if (raw) safetyConfig = JSON.parse(raw.value);
+  } catch {}
+
+  // Prompt version info
+  let promptVersion = null;
+  try {
+    promptVersion = db.prepare(
+      "SELECT version, avg_score, total_runs, created_by FROM prompt_versions WHERE is_active = 1 ORDER BY version DESC LIMIT 1"
+    ).get() as any;
+  } catch {}
+
+  // Recent actions
+  const recentActions = db.prepare(
+    "SELECT action_type, target, status, cost_usd, created_at FROM action_log ORDER BY created_at DESC LIMIT 20"
+  ).all() as any[];
+
+  // Self-improvement info
+  let selfImprovement: any = {};
+  try {
+    const lastUpdate = db.prepare("SELECT value FROM config WHERE key = 'last_self_update'").get() as any;
+    const interval = db.prepare("SELECT value FROM config WHERE key = 'self_update_interval_ms'").get() as any;
+    const totalVersions = db.prepare("SELECT COUNT(*) as cnt FROM prompt_versions").get() as any;
+    const currentVersion = db.prepare(
+      "SELECT total_runs FROM prompt_versions WHERE is_active = 1 ORDER BY version DESC LIMIT 1"
+    ).get() as any;
+
+    selfImprovement = {
+      last_update: lastUpdate?.value || null,
+      interval_hours: interval ? Math.round(parseInt(interval.value) / 3600000) : 6,
+      total_versions: totalVersions?.cnt || 1,
+      next_optimize_at: currentVersion ? "run #" + (Math.ceil((currentVersion.total_runs + 1) / 30) * 30) : "run #30",
+    };
+  } catch {}
+
+  // Log stats
+  const logFile = path.join(LOG_DIR, "agent-" + today + ".jsonl");
+  let logStats = { total: 0, errors: 0, warnings: 0 };
+  if (fs.existsSync(logFile)) {
+    const lines = fs.readFileSync(logFile, "utf-8").trim().split("\n").filter(Boolean);
+    logStats.total = lines.length;
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.level === "error") logStats.errors++;
+        if (entry.level === "warn") logStats.warnings++;
+      } catch {}
+    }
+  }
+
+  // All-time metrics
+  const allMetrics = db.prepare("SELECT * FROM daily_metrics ORDER BY date DESC LIMIT 7").all() as any[];
+  const totalCost = allMetrics.reduce((sum: number, m: any) => sum + ((m.total_cost_usd as number) || 0), 0);
+
+  // Suppression count
+  let suppressionCount = 0;
+  try {
+    suppressionCount = (db.prepare("SELECT COUNT(*) as cnt FROM suppression_list").get() as any).cnt;
+  } catch {}
+
+  // Build dashboard data
+  const dashboard = {
+    generated_at: now.toISOString(),
+    agent_name: "__AGENT_NAME__",
+    claw_type: "__CLAW_TYPE__",
+
+    today_metrics: todayMetrics,
+    circuit_breaker: circuitBreaker,
+    safety_config: safetyConfig,
+    prompt_version: promptVersion,
+    recent_actions: recentActions,
+    self_improvement: selfImprovement,
+    logs: logStats,
+    suppression_count: suppressionCount,
+    total_cost: Math.round(totalCost * 100) / 100,
+    daily_metrics: allMetrics,
+  };
+
+  fs.mkdirSync(path.dirname(OUTPUT), { recursive: true });
+  fs.writeFileSync(OUTPUT, JSON.stringify(dashboard, null, 2));
+  console.log("Dashboard data written to " + OUTPUT);
+}
+
+main();

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "create-yonderclaw",
+  "version": "1.0.0",
+  "description": "YonderClaw — Autonomous AI Agent Platform by Yonder Zenith LLC",
+  "type": "module",
+  "bin": {
+    "create-yonderclaw": "bin/create-yonderclaw.mjs"
+  },
+  "scripts": {
+    "start": "tsx installer/index.ts",
+    "create": "tsx installer/index.ts"
+  },
+  "author": "Yonder Zenith LLC",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.77",
+    "@clack/prompts": "^1.1.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/figlet": "^1.7.0",
+    "@types/gradient-string": "^1.1.6",
+    "better-sqlite3": "^12.8.0",
+    "chalk": "^5.6.2",
+    "figlet": "^1.11.0",
+    "gradient-string": "^3.0.0",
+    "hyperswarm": "^4.17.0",
+    "listr2": "^10.2.1",
+    "ora": "^9.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}