@synergenius/flow-weaver-pack-weaver 0.9.7 → 0.9.9

package/src/bot/tool-registry.ts

@@ -8,7 +8,7 @@ import type { ToolDefinition } from '@synergenius/flow-weaver/agent';
 
 export interface WeaverTool extends ToolDefinition {
   verboseOutput?: boolean;
-  category: 'bot-management' | 'queue' | 'flow-weaver' | 'project' | 'knowledge' | 'conversation' | 'ci' | 'web';
+  category: 'bot-management' | 'queue' | 'flow-weaver' | 'project' | 'knowledge' | 'conversation' | 'ci' | 'web' | 'overseer';
   contexts: Array<'bot' | 'assistant'>;
 }
 
@@ -290,7 +290,7 @@ export const ALL_TOOLS: WeaverTool[] = [
       required: ['file', 'patches'],
     },
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'write_file',
@@ -304,7 +304,7 @@ export const ALL_TOOLS: WeaverTool[] = [
       required: ['file', 'content'],
     },
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'tsc_check',
@@ -312,7 +312,7 @@ export const ALL_TOOLS: WeaverTool[] = [
     inputSchema: { type: 'object', properties: {}, required: [] },
     verboseOutput: true,
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'run_tests',
@@ -320,7 +320,7 @@ export const ALL_TOOLS: WeaverTool[] = [
     inputSchema: { type: 'object', properties: { pattern: { type: 'string', description: 'Test file pattern (optional)' } }, required: [] },
     verboseOutput: true,
     category: 'project',
-    contexts: ['bot'],
+    contexts: ['bot', 'assistant'],
   },
   {
     name: 'project_list',
@@ -434,6 +434,68 @@ export const ALL_TOOLS: WeaverTool[] = [
     contexts: ['bot', 'assistant'],
   },
 
+  // ── Overseer tools (assistant only) ─────────────────────────────
+  {
+    name: 'project_health',
+    description: 'Get project health: workflow scores, bot performance, failure patterns, cost trends, trust level.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'project_insights',
+    description: 'Get actionable insights: recurring failures, degrading workflows, cost optimizations, evolution opportunities.',
+    inputSchema: {
+      type: 'object',
+      properties: { limit: { type: 'number', description: 'Max insights (default 5)' } },
+      required: [],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'evolution_status',
+    description: 'Get genesis evolution history: cycle outcomes, operation effectiveness, recent proposals.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'genesis_propose',
+    description: 'Generate a Genesis evolution proposal for a bot workflow based on project insights. Auto-ejects bot if needed.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bot: { type: 'string', description: 'Bot name (default: weaver-bot)' },
+        focus: { type: 'string', description: 'Optional focus area for the proposal' },
+        budget: { type: 'number', description: 'Cost unit budget (default: from config)' },
+      },
+      required: [],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'improve_status',
+    description: 'Get status of the current or most recent weaver improve run — cycles, commits, successes, failures.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+  {
+    name: 'genesis_apply',
+    description: 'Apply an approved Genesis proposal to the bot workflow.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        proposal_id: { type: 'string', description: 'Proposal ID from genesis_propose' },
+      },
+      required: ['proposal_id'],
+    },
+    category: 'overseer',
+    contexts: ['assistant'],
+  },
+
   // ── Bot-only interactive ─────────────────────────────────────────
   {
     name: 'ask_user',

package/src/bot/trust-calculator.ts

@@ -0,0 +1,87 @@
+/**
+ * Trust Calculator — pure function that derives a trust level from the project model.
+ *
+ * Trust phases:
+ *   Phase 1: Insights + suggestions (default)
+ *   Phase 2: Proposals with explanation
+ *   Phase 3: Proposals with visual diff
+ *   Phase 4: Auto-apply COSMETIC changes
+ */
+
+import type { TrustLevel } from './types.js';
+
+interface TrustInput {
+  health: { workflows: Array<{ lastRun: string | null }> };
+  userPreferences: { approvalHistory: Array<{ approved: boolean; impactLevel: string }> };
+  evolution: { totalCycles: number; successRate: number };
+  cost: { last7Days: number };
+  _conversationCount?: number;
+}
+
+export function computeTrustLevel(model: TrustInput): TrustLevel {
+  const conversationCount = model._conversationCount ?? 0;
+  const approvalHistory = model.userPreferences.approvalHistory;
+  const approvalCount = approvalHistory.length;
+  const approvalRate = approvalCount > 0
+    ? approvalHistory.filter(a => a.approved).length / approvalCount
+    : 0;
+  const genesisSuccessRate = model.evolution.totalCycles > 0 ? model.evolution.successRate : 0;
+
+  // Estimate days since first use from earliest workflow run
+  const timestamps: number[] = [];
+  for (const w of model.health.workflows) {
+    if (w.lastRun) timestamps.push(new Date(w.lastRun).getTime());
+  }
+  const earliest = timestamps.length > 0 ? Math.min(...timestamps) : Date.now();
+  const daysSinceFirstUse = Math.max(0, Math.round((Date.now() - earliest) / 86_400_000));
+
+  // COSMETIC-specific approval rate
+  const cosmeticApprovals = approvalHistory.filter(a => a.impactLevel === 'COSMETIC');
+  const cosmeticApprovalRate = cosmeticApprovals.length > 0
+    ? cosmeticApprovals.filter(a => a.approved).length / cosmeticApprovals.length
+    : 0;
+
+  // Weighted score (0-100)
+  const score = Math.round(
+    Math.min(conversationCount / 30, 1) * 25 +
+    approvalRate * 25 +
+    genesisSuccessRate * 25 +
+    Math.min(daysSinceFirstUse / 30, 1) * 25,
+  );
+
+  // Phase thresholds
+  let phase: 1 | 2 | 3 | 4 = 1;
+  if (
+    conversationCount >= 30 &&
+    cosmeticApprovalRate >= 0.85 &&
+    cosmeticApprovals.length >= 3 &&
+    daysSinceFirstUse >= 7
+  ) {
+    phase = 4;
+  } else if (
+    conversationCount >= 15 &&
+    approvalRate >= 0.7 &&
+    approvalCount >= 5 &&
+    model.evolution.totalCycles >= 3 &&
+    genesisSuccessRate >= 0.5
+  ) {
+    phase = 3;
+  } else if (
+    conversationCount >= 5 &&
+    approvalCount >= 3 &&
+    approvalRate >= 0.6
+  ) {
+    phase = 2;
+  }
+
+  return {
+    score,
+    phase,
+    factors: {
+      conversationCount,
+      approvalConsistency: approvalRate,
+      genesisSuccessRate,
+      daysSinceFirstUse,
+    },
+  };
+}

package/src/bot/types.ts

@@ -471,6 +471,108 @@ export interface GenesisFingerprint {
   existingWorkflows: string[];
 }
 
+// --- Project Model (Overseer) ---
+
+export interface WorkflowHealth {
+  file: string;
+  score: number;
+  totalRuns: number;
+  successRate: number;
+  avgDurationMs: number;
+  lastRun: string | null;
+  trend: 'improving' | 'stable' | 'degrading';
+}
+
+export interface FailurePattern {
+  pattern: string;
+  category: string;
+  occurrences: number;
+  lastSeen: string;
+  workflows: string[];
+  transient: boolean;
+}
+
+export interface ApprovalDecision {
+  timestamp: string;
+  proposalSummary: string;
+  impactLevel: string;
+  approved: boolean;
+  reason?: string;
+}
+
+export interface OperationEffectiveness {
+  proposed: number;
+  applied: number;
+  rolledBack: number;
+  effectiveness: number;
+}
+
+export interface TrustLevel {
+  score: number;
+  phase: 1 | 2 | 3 | 4;
+  factors: {
+    conversationCount: number;
+    approvalConsistency: number;
+    genesisSuccessRate: number;
+    daysSinceFirstUse: number;
+  };
+}
+
+export interface BotProfile {
+  name: string;
+  workflowFile: string;
+  ejected: boolean;
+  totalTasksRun: number;
+  successRate: number;
+  avgTaskDurationMs: number;
+  topFailurePatterns: FailurePattern[];
+}
+
+export interface ProjectModel {
+  projectDir: string;
+  builtAt: number;
+  health: {
+    overall: number;
+    workflows: WorkflowHealth[];
+  };
+  bots: BotProfile[];
+  failurePatterns: FailurePattern[];
+  userPreferences: {
+    approvalHistory: ApprovalDecision[];
+    autoApprovePatterns: string[];
+    neverApprovePatterns: string[];
+  };
+  evolution: {
+    totalCycles: number;
+    successRate: number;
+    byOperationType: Record<string, OperationEffectiveness>;
+    recentCycles: GenesisCycleRecord[];
+  };
+  cost: {
+    totalSpent: number;
+    last7Days: number;
+    last30Days: number;
+    trend: 'increasing' | 'stable' | 'decreasing';
+    costPerSuccessfulRun: number;
+    highCostWorkflows: Array<{ workflow: string; avgCost: number }>;
+  };
+  trust: TrustLevel;
+}
+
+export interface Insight {
+  id: string;
+  type: 'failure-pattern' | 'health-trend' | 'cost-optimization' | 'evolution-opportunity' | 'unused-workflow' | 'bot-performance' | 'update-available';
+  confidence: number;
+  severity: 'info' | 'warning' | 'critical';
+  title: string;
+  description: string;
+  evidence: string[];
+  suggestion?: string;
+  genesisCandidate: boolean;
+  targetBot?: string;
+  operationHint?: string;
+}
+
 export interface GenesisCycleRecord {
   id: string;
   timestamp: string;
@@ -483,6 +585,7 @@ export interface GenesisCycleRecord {
   approved: boolean | null;
   error: string | null;
   snapshotFile: string | null;
+  rejectionReason?: string;
 }
 
 export interface GenesisHistory {
@@ -519,6 +622,7 @@ export interface GenesisContext {
   workflowDiffJson?: string;
   approvalRequired?: boolean;
   approved?: boolean;
+  rejectionReason?: string;
   commitResultJson?: string;
   cycleRecordJson?: string;
   workflowDescription?: string;

package/src/bot/update-checker.ts

@@ -0,0 +1,138 @@
+/**
+ * Update Checker — checks npm registry for newer versions of installed packs.
+ * Results are cached for 24 hours to avoid spamming the registry.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { safeJsonParse } from './safe-json.js';
+
+export interface UpdateInfo {
+  packageName: string;
+  currentVersion: string;
+  latestVersion: string;
+  updateAvailable: boolean;
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const CACHE_DIR = path.join(os.homedir(), '.weaver');
+const CACHE_FILE = path.join(CACHE_DIR, 'update-cache.json');
+
+interface CacheEntry {
+  checkedAt: number;
+  updates: UpdateInfo[];
+}
+
+function readCache(): CacheEntry | null {
+  try {
+    if (!fs.existsSync(CACHE_FILE)) return null;
+    const text = fs.readFileSync(CACHE_FILE, 'utf-8');
+    const parsed = safeJsonParse<CacheEntry>(text, 'update-cache');
+    if (!parsed.ok) {
+      console.error(`[weaver] ${parsed.error}`);
+      return null;
+    }
+    if (Date.now() - parsed.value.checkedAt < CACHE_TTL_MS) return parsed.value;
+    return null; // stale
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(entry: CacheEntry): void {
+  try {
+    fs.mkdirSync(CACHE_DIR, { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(entry, null, 2), 'utf-8');
+  } catch { /* non-fatal */ }
+}
+
+export function compareVersions(a: string, b: string): number {
+  const pa = a.replace(/^v/, '').split('.').map(s => parseInt(s, 10) || 0);
+  const pb = b.replace(/^v/, '').split('.').map(s => parseInt(s, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string | null> {
+  try {
+    const encoded = packageName.replace('/', '%2f');
+    const resp = await fetch(`https://registry.npmjs.org/${encoded}/latest`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json() as { version?: string };
+    return data.version ?? null;
+  } catch {
+    return null; // network error, timeout, etc.
+  }
+}
+
+/**
+ * Check for updates on installed packs. Returns cached result if fresh.
+ * Checks: the weaver pack itself, and any flow-weaver-pack-* in node_modules.
+ */
+export async function checkForUpdates(projectDir: string): Promise<UpdateInfo[]> {
+  // Return cached if fresh
+  const cached = readCache();
+  if (cached) return cached.updates;
+
+  const updates: UpdateInfo[] = [];
+
+  // Check the weaver pack itself
+  try {
+    const packPkgPath = path.resolve(projectDir, 'node_modules', '@synergenius', 'flow-weaver-pack-weaver', 'package.json');
+    if (fs.existsSync(packPkgPath)) {
+      const text = fs.readFileSync(packPkgPath, 'utf-8');
+      const parsed = safeJsonParse<{ name: string; version: string }>(text, 'pack-weaver package.json');
+      if (!parsed.ok) {
+        console.error(`[weaver] ${parsed.error}`);
+      } else {
+        const pkg = parsed.value;
+        const current = pkg.version;
+        const latest = await fetchLatestVersion(pkg.name);
+        if (latest && compareVersions(latest, current) > 0) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: true });
+        } else if (latest) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: false });
+        }
+      }
+    }
+  } catch { /* not installed or unreadable */ }
+
+  // Check flow-weaver core
+  try {
+    const corePkgPath = path.resolve(projectDir, 'node_modules', '@synergenius', 'flow-weaver', 'package.json');
+    if (fs.existsSync(corePkgPath)) {
+      const text = fs.readFileSync(corePkgPath, 'utf-8');
+      const parsed = safeJsonParse<{ name: string; version: string }>(text, 'flow-weaver package.json');
+      if (!parsed.ok) {
+        console.error(`[weaver] ${parsed.error}`);
+      } else {
+        const pkg = parsed.value;
+        const current = pkg.version;
+        const latest = await fetchLatestVersion(pkg.name);
+        if (latest && compareVersions(latest, current) > 0) {
+          updates.push({ packageName: pkg.name, currentVersion: current, latestVersion: latest, updateAvailable: true });
+        }
+      }
+    }
+  } catch { /* not installed */ }
+
+  // Cache result
+  writeCache({ checkedAt: Date.now(), updates });
+  return updates;
+}
+
+/**
+ * Format update info as a brief notification string.
+ */
+export function formatUpdateNotification(updates: UpdateInfo[]): string | null {
+  const available = updates.filter(u => u.updateAvailable);
+  if (available.length === 0) return null;
+  const lines = available.map(u => `${u.packageName}: ${u.currentVersion} → ${u.latestVersion}`);
+  return `Updates available:\n${lines.join('\n')}\nRun: npm update`;
+}

package/src/bot/weaver-tools.ts

@@ -41,9 +41,14 @@ export function createWeaverExecutor(projectDir: string) {
         if (isBlockedUrl(url)) {
           return { result: 'Blocked: cannot fetch internal/localhost URLs.', isError: true };
         }
-        const resp = await fetch(url, { method: (args.method as string) ?? 'GET', signal: AbortSignal.timeout(15_000) });
-        const text = await resp.text();
-        return { result: text.slice(0, 10_000), isError: !resp.ok };
+        try {
+          const resp = await fetch(url, { method: (args.method as string) ?? 'GET', signal: AbortSignal.timeout(15_000) });
+          const text = await resp.text();
+          return { result: text.slice(0, 10_000), isError: !resp.ok };
+        } catch (err: unknown) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { result: `Fetch error: ${msg}`, isError: true };
+        }
       }
 
       case 'tsc_check': {
@@ -68,7 +73,8 @@ export function createWeaverExecutor(projectDir: string) {
             const failures = (json.testResults ?? []).filter((t: any) => t.status === 'failed').map((t: any) => t.name).slice(0, 10);
             return { result: JSON.stringify({ passed, failed, total: passed + failed, failures }), isError: failed > 0 };
           } catch {
-            return { result: output.slice(0, 5000), isError: false };
+            // JSON parse failed — output is not structured, flag as error
+            return { result: output.slice(0, 5000), isError: true };
           }
         } catch (err: any) {
           return { result: (err.stdout ?? err.stderr ?? err.message ?? '').slice(0, 5000), isError: true };

package/src/cli-bridge.ts

@@ -4,7 +4,7 @@ import {
   handleCron, handlePipeline, handleDashboard, handleProviders,
   handleEject, handleBot, handleSession, handleSteer, handleQueue,
   handleStatus, handleGenesis, handleAudit, handleInit, handleAssistant,
-  handleExamples, handleDoctor,
+  handleExamples, handleDoctor, handleImprove,
   printHelp,
 } from './cli-handlers.js';
 
@@ -29,8 +29,11 @@ const handlers: Record<string, (opts: ParsedArgs) => Promise<void>> = {
   assistant: handleAssistant,
   examples: handleExamples,
   doctor: handleDoctor,
+  improve: handleImprove,
 };
 
+export { printHelp };
+
 export async function handleCommand(
   name: string,
   args: string[],