@synergenius/flow-weaver-pack-weaver 0.9.8 → 0.9.10

package/src/handlers/on-execution-completed.ts

@@ -0,0 +1,30 @@
+/**
+ * Platform event handler: invalidates project model cache when executions complete.
+ * Registered in flowweaver.manifest.json as an event subscription.
+ */
+
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export async function onExecutionCompleted(event: {
+  deploymentId?: string;
+  wsPath?: string;
+  status?: string;
+  executionTimeMs?: number;
+}): Promise<void> {
+  const projectDir = event.wsPath;
+  if (!projectDir) return;
+
+  // Invalidate project model cache directly (same logic as ProjectModelStore.invalidate)
+  try {
+    const hash8 = crypto.createHash('sha256').update(projectDir).digest('hex').slice(0, 8);
+    const modelPath = path.join(os.homedir(), '.weaver', 'projects', hash8, 'model.json');
+    if (fs.existsSync(modelPath)) {
+      fs.unlinkSync(modelPath);
+    }
+  } catch {
+    // Non-fatal — cache will be rebuilt on next access
+  }
+}

package/src/mcp-tools.ts

@@ -271,4 +271,42 @@ export async function registerMcpTools(mcp: McpServer): Promise<void> {
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     },
   );
+
+  mcp.tool(
+    'fw_weaver_insights',
+    'Get project health, insights, trust level, and cost summary. Returns structured JSON with actionable recommendations.',
+    {
+      projectDir: z.string().describe('Project directory path'),
+    },
+    async (args) => {
+      try {
+        const { ProjectModelStore } = await import('./bot/project-model.js');
+        const { InsightEngine } = await import('./bot/insight-engine.js');
+        const pms = new ProjectModelStore(args.projectDir as string);
+        const model = await pms.getOrBuild();
+        const engine = new InsightEngine();
+        const insights = engine.analyze(model);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              health: model.health,
+              bots: model.bots,
+              insights: insights.slice(0, 10),
+              trust: model.trust,
+              cost: model.cost,
+              evolution: {
+                totalCycles: model.evolution.totalCycles,
+                successRate: model.evolution.successRate,
+              },
+            }, null, 2),
+          }],
+        };
+      } catch (err: unknown) {
+        return {
+          content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+        };
+      }
+    },
+  );
 }

package/src/node-types/genesis-approve.ts

@@ -66,8 +66,33 @@ export async function genesisApprove(
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   }
 
-  // Non-auto modes reject in non-interactive context
-  console.log('\x1b[33m→ Rejected (approval required, non-auto mode)\x1b[0m');
-  context.approved = false;
+  // Non-auto modes: try interactive approval, fall back to reject
+  let approved = false;
+  let rejectionReason = 'Non-interactive environment';
+
+  if (approvalMode === 'prompt') {
+    try {
+      const readline = await import('node:readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise<string>(resolve => {
+        rl.question('\x1b[33m? Approve this proposal? (y/N/reason): \x1b[0m', resolve);
+      });
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === 'y' || trimmed === 'yes') {
+        approved = true;
+      } else {
+        rejectionReason = trimmed && trimmed !== 'n' && trimmed !== 'no' ? answer.trim() : 'User rejected';
+      }
+    } catch {
+      // Non-interactive — fall through to reject
+    }
+  }
+
+  context.approved = approved;
+  context.rejectionReason = approved ? undefined : rejectionReason;
+  console.log(approved
+    ? '\x1b[32m→ Approved by user\x1b[0m'
+    : `\x1b[33m→ Rejected: ${rejectionReason}\x1b[0m`);
   return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
 }

package/src/node-types/genesis-observe.ts

@@ -46,22 +46,28 @@ export async function genesisObserve(
 
   try {
     const files: Record<string, string> = {};
-    const dirsToScan = [projectDir];
-    const srcDir = path.join(projectDir, 'src');
-    if (fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) dirsToScan.push(srcDir);
+    const fileContents: Record<string, string> = {};
+    const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'coverage', '.next', '.turbo']);
 
-    for (const dir of dirsToScan) {
+    function walkDir(dir: string): void {
       const entries = fs.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isFile() && entry.name.endsWith('.ts')) {
+        if (entry.isDirectory()) {
+          if (!SKIP_DIRS.has(entry.name)) {
+            walkDir(path.join(dir, entry.name));
+          }
+        } else if (entry.isFile() && entry.name.endsWith('.ts')) {
           const filePath = path.join(dir, entry.name);
           const relPath = path.relative(projectDir, filePath);
           const content = fs.readFileSync(filePath, 'utf-8');
+          fileContents[relPath] = content;
           files[relPath] = crypto.createHash('sha256').update(content).digest('hex');
         }
       }
     }
 
+    walkDir(projectDir);
+
     let packageJson: Record<string, unknown> | null = null;
     const pkgPath = path.join(projectDir, 'package.json');
     if (fs.existsSync(pkgPath)) {
@@ -83,17 +89,20 @@ export async function genesisObserve(
     }
 
     const existingWorkflows: string[] = [];
-    for (const [relPath, _hash] of Object.entries(files)) {
-      const filePath = path.join(projectDir, relPath);
-      const content = fs.readFileSync(filePath, 'utf-8');
+    for (const [relPath, content] of Object.entries(fileContents)) {
       if (content.includes('@flowWeaver workflow')) {
         existingWorkflows.push(relPath);
       }
     }
 
-    const targetPath = path.resolve(projectDir, config.targetWorkflow);
-    const targetContent = fs.readFileSync(targetPath, 'utf-8');
-    const workflowHash = crypto.createHash('sha256').update(targetContent).digest('hex');
+    let workflowHash = '';
+    let targetPath = '';
+    if (config.targetWorkflow) {
+      targetPath = path.resolve(projectDir, config.targetWorkflow);
+      const targetRelPath = path.relative(projectDir, targetPath);
+      const targetContent = fileContents[targetRelPath] ?? fs.readFileSync(targetPath, 'utf-8');
+      workflowHash = crypto.createHash('sha256').update(targetContent).digest('hex');
+    }
 
     const fingerprint: GenesisFingerprint = {
       timestamp: new Date().toISOString(),
@@ -108,7 +117,9 @@ export async function genesisObserve(
     console.log(`\x1b[36m→ Fingerprint: ${Object.keys(files).length} files, ${existingWorkflows.length} workflows\x1b[0m`);
 
     context.fingerprintJson = JSON.stringify(fingerprint);
-    context.workflowDescription = await getWorkflowDescription(targetPath);
+    if (targetPath) {
+      context.workflowDescription = await getWorkflowDescription(targetPath);
+    }
 
     return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
   } catch (err: unknown) {

package/src/node-types/genesis-propose.ts

@@ -40,10 +40,18 @@ export async function genesisPropose(
     graceRemaining: context.escrowGraceRemaining ?? 0,
   });
 
+  // Inject project intelligence
+  let insightContext = '';
+  try {
+    const { getGenesisInsightContext } = await import('../bot/genesis-prompt-context.js');
+    insightContext = await getGenesisInsightContext(env.projectDir);
+  } catch { /* insights not available */ }
+
   const userPrompt = [
     '## Current Workflow Structure',
     context.workflowDescription || '(no description available)',
     '',
+    ...(insightContext ? [insightContext, ''] : []),
     '## Project Diff Since Last Cycle',
     JSON.stringify(diff, null, 2),
     '',

package/src/node-types/genesis-update-history.ts

@@ -60,6 +60,18 @@ export function genesisUpdateHistory(ctx: string): { ctx: string } {
     if (fingerprint) {
       store.saveFingerprint(fingerprint);
     }
+
+    // Invalidate project model cache so next access rebuilds with fresh data
+    try {
+      // Use sync require-like approach: delete the cached model.json directly
+      const crypto = require('node:crypto') as typeof import('node:crypto');
+      const fsMod = require('node:fs') as typeof import('node:fs');
+      const pathMod = require('node:path') as typeof import('node:path');
+      const osMod = require('node:os') as typeof import('node:os');
+      const hash8 = crypto.createHash('sha256').update(env.projectDir).digest('hex').slice(0, 8);
+      const modelPath = pathMod.join(osMod.homedir(), '.weaver', 'projects', hash8, 'model.json');
+      if (fsMod.existsSync(modelPath)) fsMod.unlinkSync(modelPath);
+    } catch { /* project model not available */ }
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`\x1b[31m→ Failed to save history: ${msg}\x1b[0m`);

package/src/ui/evolution-panel.tsx

@@ -0,0 +1,96 @@
+/**
+ * Weaver Evolution Panel — shows Genesis cycle history and operation effectiveness.
+ * Loaded dynamically by the platform's pack UI contributions loader.
+ */
+
+import React, { useEffect, useState } from 'react';
+
+interface EvolutionData {
+  evolution: {
+    totalCycles: number;
+    successRate: number;
+    byOperationType: Record<string, { proposed: number; applied: number; effectiveness: number }>;
+    recentCycles: Array<{ id: string; outcome: string; proposal?: { summary: string; impactLevel: string } }>;
+  };
+  trust: { phase: number; score: number };
+}
+
+export function WeaverEvolutionPanel({ projectDir }: { projectDir?: string }) {
+  const [data, setData] = useState<EvolutionData | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!projectDir) return;
+    fetch(`/api/mcp/fw_weaver_insights?projectDir=${encodeURIComponent(projectDir)}`)
+      .then(r => r.json())
+      .then(setData)
+      .catch(e => setError(e.message));
+  }, [projectDir]);
+
+  if (error) return <div style={{ padding: 16, color: '#ef4444' }}>Error: {error}</div>;
+  if (!data) return <div style={{ padding: 16, opacity: 0.5 }}>Loading evolution data...</div>;
+
+  const { evolution, trust } = data;
+  const outcomeColor: Record<string, string> = {
+    applied: '#22c55e',
+    'rolled-back': '#ef4444',
+    rejected: '#f59e0b',
+    'no-change': '#6b7280',
+    error: '#ef4444',
+  };
+
+  return (
+    <div style={{ padding: 16, fontFamily: 'system-ui, sans-serif', fontSize: 13 }}>
+      <div style={{ marginBottom: 16 }}>
+        <div style={{ fontWeight: 600, marginBottom: 4 }}>Trust Level</div>
+        <div style={{ display: 'flex', alignItems: 'baseline', gap: 8 }}>
+          <span style={{ fontSize: 20, fontWeight: 700 }}>Phase {trust.phase}</span>
+          <span style={{ opacity: 0.5 }}>Score: {trust.score}/100</span>
+        </div>
+      </div>
+
+      <div style={{ marginBottom: 16 }}>
+        <div style={{ fontWeight: 600, marginBottom: 4 }}>
+          Genesis Cycles: {evolution.totalCycles} ({evolution.totalCycles > 0 ? Math.round(evolution.successRate * 100) : 0}% success)
+        </div>
+      </div>
+
+      {Object.keys(evolution.byOperationType).length > 0 && (
+        <div style={{ marginBottom: 16 }}>
+          <div style={{ fontWeight: 600, marginBottom: 4 }}>Operation Effectiveness</div>
+          {Object.entries(evolution.byOperationType).map(([op, stats]) => (
+            <div key={op} style={{ padding: '2px 0', display: 'flex', justifyContent: 'space-between' }}>
+              <span>{op}</span>
+              <span style={{ opacity: 0.7 }}>{Math.round(stats.effectiveness * 100)}% ({stats.applied}/{stats.proposed})</span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {evolution.recentCycles.length > 0 && (
+        <div>
+          <div style={{ fontWeight: 600, marginBottom: 4 }}>Recent Cycles</div>
+          {evolution.recentCycles.slice(-5).reverse().map((cycle) => (
+            <div key={cycle.id} style={{ padding: '4px 0', borderBottom: '1px solid rgba(128,128,128,0.1)' }}>
+              <span style={{ color: outcomeColor[cycle.outcome] ?? '#6b7280', fontWeight: 600, marginRight: 8 }}>
+                {cycle.outcome}
+              </span>
+              <span style={{ opacity: 0.7 }}>{cycle.id}</span>
+              {cycle.proposal && (
+                <div style={{ opacity: 0.6, paddingLeft: 8 }}>{cycle.proposal.summary}</div>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {evolution.totalCycles === 0 && (
+        <div style={{ opacity: 0.5, textAlign: 'center', padding: 20 }}>
+          No genesis cycles yet. Use /genesis in the assistant to start evolving bot workflows.
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default WeaverEvolutionPanel;

package/src/ui/insights-widget.tsx

@@ -0,0 +1,77 @@
+/**
+ * Weaver Insights Dashboard Widget — shows project health, insights, and cost summary.
+ * Loaded dynamically by the platform's pack UI contributions loader.
+ */
+
+import React, { useEffect, useState } from 'react';
+
+interface InsightsData {
+  health: { overall: number; workflows: Array<{ file: string; score: number; trend: string }> };
+  bots: Array<{ name: string; ejected: boolean; successRate: number; totalTasksRun: number }>;
+  insights: Array<{ severity: string; title: string; description: string; confidence: number }>;
+  cost: { last7Days: number; trend: string };
+  trust: { phase: number; score: number };
+}
+
+export function WeaverInsightsWidget({ projectDir }: { projectDir?: string }) {
+  const [data, setData] = useState<InsightsData | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!projectDir) return;
+    fetch(`/api/mcp/fw_weaver_insights?projectDir=${encodeURIComponent(projectDir)}`)
+      .then(r => r.json())
+      .then(setData)
+      .catch(e => setError(e.message));
+  }, [projectDir]);
+
+  if (error) return <div style={{ padding: 16, color: '#ef4444' }}>Error: {error}</div>;
+  if (!data) return <div style={{ padding: 16, opacity: 0.5 }}>Loading insights...</div>;
+
+  const severityColor: Record<string, string> = {
+    critical: '#ef4444',
+    warning: '#f59e0b',
+    info: '#6b7280',
+  };
+
+  return (
+    <div style={{ padding: 16, fontFamily: 'system-ui, sans-serif', fontSize: 13 }}>
+      <div style={{ display: 'flex', alignItems: 'baseline', gap: 12, marginBottom: 12 }}>
+        <span style={{ fontSize: 28, fontWeight: 700 }}>{data.health.overall}</span>
+        <span style={{ opacity: 0.6 }}>/100 health</span>
+        <span style={{ marginLeft: 'auto', opacity: 0.5 }}>
+          Phase {data.trust.phase} · ${data.cost.last7Days.toFixed(2)}/7d ({data.cost.trend})
+        </span>
+      </div>
+
+      {data.insights.length > 0 && (
+        <div style={{ marginBottom: 12 }}>
+          <div style={{ fontWeight: 600, marginBottom: 6 }}>Insights</div>
+          {data.insights.slice(0, 3).map((insight, i) => (
+            <div key={i} style={{ padding: '4px 0', borderBottom: '1px solid rgba(128,128,128,0.1)' }}>
+              <span style={{ color: severityColor[insight.severity] ?? '#6b7280', fontWeight: 600, marginRight: 8 }}>
+                {insight.severity.toUpperCase()}
+              </span>
+              <span>{insight.title}</span>
+              <span style={{ opacity: 0.5, marginLeft: 8 }}>{Math.round(insight.confidence * 100)}%</span>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {data.bots.length > 0 && (
+        <div>
+          <div style={{ fontWeight: 600, marginBottom: 6 }}>Bots</div>
+          {data.bots.map((bot, i) => (
+            <div key={i} style={{ padding: '2px 0' }}>
+              {bot.name}: {Math.round(bot.successRate * 100)}% success ({bot.totalTasksRun} tasks)
+              {bot.ejected && <span style={{ opacity: 0.5 }}> · ejected</span>}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default WeaverInsightsWidget;