@claude-flow/cli 3.21.1 → 3.22.0

package/scripts/benchmark-self-learning.mjs

@@ -1,241 +0,0 @@
-#!/usr/bin/env node
-// benchmark-self-learning.mjs — proof harness for #2245.
-//
-// Replaces the "self-learning reports success but persists nothing" theater
-// with measured deltas: actually runs each entry point N times and prints what
-// each one moved (or didn't). Writes a run JSON to docs/benchmarks/runs/ so
-// future regressions are visible against a committed baseline.
-//
-// Usage:
-//   node scripts/benchmark-self-learning.mjs                  # default N=20 per surface
-//   N=50 BENCH_JSON=1 node scripts/benchmark-self-learning.mjs
-//   BENCH_NO_WRITE=1 node scripts/benchmark-self-learning.mjs
-//
-// Repro:
-//   1. Clone ruvnet/ruflo, npm install, build the CLI:
-//        npm install && (cd v3/@claude-flow/cli && npx tsc -b)
-//   2. Run this script. It prints a "before/after" table per surface.
-//   3. Inspect docs/benchmarks/runs/self-learning-<ts>.json for the persisted
-//      proof — diff against previous runs to catch any future regression.
-
-import { mkdirSync, writeFileSync, mkdtempSync, rmSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import { performance } from 'node:perf_hooks';
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(SCRIPT_DIR, '..');
-const REPO_ROOT = resolve(SCRIPT_DIR, '../../../..');
-const RUNS_DIR = join(REPO_ROOT, 'docs', 'benchmarks', 'runs');
-
-const N = Number(process.env.N) || 20;
-
-// Run in an isolated temp dir so we don't pollute the repo's neural store.
-const SCRATCH = mkdtempSync(join(tmpdir(), 'learn-bench-'));
-process.chdir(SCRATCH);
-
-async function main() {
-  const intel = await import(join(CLI_ROOT, 'dist/src/memory/intelligence.js'));
-  const hooks = await import(join(CLI_ROOT, 'dist/src/mcp-tools/hooks-tools.js'));
-  const neural = await import(join(CLI_ROOT, 'dist/src/mcp-tools/neural-tools.js'));
-
-  intel.clearIntelligence();
-
-  // -------------------------------------------------------------------------
-  // §A — recordSignalProcessed
-  // -------------------------------------------------------------------------
-  const A_before = intel.getIntelligenceStats();
-  const tA = performance.now();
-  for (let i = 0; i < N; i++) intel.recordSignalProcessed();
-  intel.flushIntelligenceStats();
-  const dtA = performance.now() - tA;
-  const A_after = intel.getIntelligenceStats();
-  const A_delta = A_after.signalsProcessed - A_before.signalsProcessed;
-
-  // -------------------------------------------------------------------------
-  // §B — hooks_task-completed (trainPatterns:true) → trajectory pipeline
-  // -------------------------------------------------------------------------
-  const taskCompleted = hooks.hooksTools.find((t) => t.name === 'hooks_task-completed');
-  const B_before = intel.getIntelligenceStats();
-  const tB = performance.now();
-  let B_trained = 0;
-  for (let i = 0; i < N; i++) {
-    const r = await taskCompleted.handler({
-      taskId: `bench-${i}`,
-      success: i % 5 !== 4, // 80% success, 20% failure — mixed verdict
-      quality: 0.5 + (i % 5) * 0.1,
-      trainPatterns: true,
-      content: `Benchmark task ${i}: refactor or test or fix`,
-    });
-    if (r.learningPath === 'trajectory-pipeline') B_trained++;
-  }
-  const dtB = performance.now() - tB;
-  const B_after = intel.getIntelligenceStats();
-
-  // -------------------------------------------------------------------------
-  // §C — hooks_task-completed recorded-only (negative control)
-  // -------------------------------------------------------------------------
-  const C_before = intel.getIntelligenceStats();
-  const tC = performance.now();
-  for (let i = 0; i < N; i++) {
-    await taskCompleted.handler({ taskId: `bench-no-train-${i}`, success: true, quality: 0.8 });
-  }
-  const dtC = performance.now() - tC;
-  const C_after = intel.getIntelligenceStats();
-
-  // -------------------------------------------------------------------------
-  // §D — storeNeuralPatterns + neural_patterns list reflects them
-  // -------------------------------------------------------------------------
-  const items = Array.from({ length: N }, (_, i) => ({
-    name: `pattern-${i}`,
-    type: 'bench-pattern',
-    content: `import { thing${i} } from 'module${i}'`,
-  }));
-  const tD = performance.now();
-  const D_store = await neural.storeNeuralPatterns(items);
-  const dtD = performance.now() - tD;
-  const listTool = neural.neuralTools.find((t) => t.name === 'neural_patterns');
-  const D_list = await listTool.handler({ action: 'list' });
-
-  // -------------------------------------------------------------------------
-  // §E — multi-step trajectory pipeline (end-to-end)
-  // -------------------------------------------------------------------------
-  const trajStart = hooks.hooksTools.find((t) => t.name === 'hooks_intelligence_trajectory-start');
-  const trajStep  = hooks.hooksTools.find((t) => t.name === 'hooks_intelligence_trajectory-step');
-  const trajEnd   = hooks.hooksTools.find((t) => t.name === 'hooks_intelligence_trajectory-end');
-  // NOTE: the MCP trajectory tools feed sonaCoordinator (queryable via
-  // hooks_intelligence_stats), NOT globalStats. That's part of the broader
-  // store-fragmentation problem #2245 identifies; we check observable
-  // outcomes (persisted + sonaUpdate) instead of a globalStats delta.
-  const tE = performance.now();
-  let persistedCount = 0;
-  let sonaUpdateCount = 0;
-  if (trajStart && trajStep && trajEnd) {
-    for (let i = 0; i < Math.min(5, N); i++) {
-      const s = await trajStart.handler({ task: `multi-step bench ${i}`, agent: 'bench' });
-      const id = s.trajectoryId;
-      await trajStep.handler({ trajectoryId: id, type: 'observation', content: `obs ${i}` });
-      await trajStep.handler({ trajectoryId: id, type: 'action',      content: `act ${i}` });
-      await trajStep.handler({ trajectoryId: id, type: 'result',      content: `done ${i}` });
-      const endRes = await trajEnd.handler({ trajectoryId: id, success: true });
-      if (endRes.persisted) persistedCount++;
-      if (endRes.learning?.sonaUpdate) sonaUpdateCount++;
-    }
-  }
-  const dtE = performance.now() - tE;
-
-  // -------------------------------------------------------------------------
-  // §F — getUnifiedLearningStats (ADR-075)
-  // -------------------------------------------------------------------------
-  const tF = performance.now();
-  const unified = await intel.getUnifiedLearningStats();
-  const dtF = performance.now() - tF;
-  const unifiedOk = unified.global && unified.sona && unified.memoryBridge && unified.neuralPatterns && unified.consistency;
-
-  // -------------------------------------------------------------------------
-  // Summary
-  // -------------------------------------------------------------------------
-  const summary = {
-    runAt: new Date().toISOString(),
-    benchmark: 'self-learning-2245',
-    n: N,
-    sections: {
-      A_recordSignalProcessed: {
-        calls: N,
-        signalsProcessedDelta: A_delta,
-        passed: A_delta === N,
-        elapsedMs: Number(dtA.toFixed(2)),
-      },
-      B_taskCompleted_trainPatterns: {
-        calls: N,
-        trainedViaPipeline: B_trained,
-        trajectoriesDelta: B_after.trajectoriesRecorded - B_before.trajectoriesRecorded,
-        patternsLearnedDelta: B_after.patternsLearned - B_before.patternsLearned,
-        passed: B_trained === N,
-        elapsedMs: Number(dtB.toFixed(2)),
-        avgLatencyMsPerCall: Number((dtB / N).toFixed(2)),
-      },
-      C_taskCompleted_recordedOnly: {
-        calls: N,
-        trajectoriesDelta: C_after.trajectoriesRecorded - C_before.trajectoriesRecorded,
-        passed: (C_after.trajectoriesRecorded - C_before.trajectoriesRecorded) === 0,
-        note: 'negative control — should NOT touch trajectories',
-        elapsedMs: Number(dtC.toFixed(2)),
-      },
-      D_pretrain_neuralPatterns: {
-        attempted: items.length,
-        stored: D_store.stored,
-        listTotal: D_list.total,
-        passed: D_store.stored === items.length && D_list.total >= items.length,
-        elapsedMs: Number(dtD.toFixed(2)),
-      },
-      E_multiStepTrajectory: {
-        cycles: Math.min(5, N),
-        persistedCount,
-        sonaUpdateCount,
-        passed: persistedCount === Math.min(5, N), // persistence is the must-pass; SONA depends on env
-        note: 'MCP trajectory tools feed sonaCoordinator (see hooks_intelligence_stats), not globalStats — observable outcomes checked here',
-        elapsedMs: Number(dtE.toFixed(2)),
-      },
-      F_unifiedStats: {
-        shape: ['global', 'sona', 'memoryBridge', 'neuralPatterns', 'consistency'],
-        observed: {
-          'global.patternsLearned': unified.global.patternsLearned,
-          'global.trajectoriesRecorded': unified.global.trajectoriesRecorded,
-          'global.signalsProcessed': unified.global.signalsProcessed,
-          'memoryBridge.totalEntries': unified.memoryBridge.totalEntries,
-          'memoryBridge.reachable': unified.memoryBridge.reachable,
-          'neuralPatterns.patternCount': unified.neuralPatterns.patternCount,
-          'sona.available': unified.sona.available,
-          'consistency.notes': unified.consistency.notes.length,
-        },
-        passed: !!unifiedOk,
-        note: 'ADR-075 — one aggregator across the 4 stores. Each sub-view names its source.',
-        elapsedMs: Number(dtF.toFixed(2)),
-      },
-    },
-    finalState: {
-      signalsProcessed: A_after.signalsProcessed,
-      trajectoriesRecorded: intel.getIntelligenceStats().trajectoriesRecorded,
-      patternsLearned: intel.getIntelligenceStats().patternsLearned,
-    },
-    scratch: SCRATCH,
-  };
-
-  const allPassed = Object.values(summary.sections).every((s) => s.passed);
-  summary.passed = allPassed;
-
-  if (process.env.BENCH_JSON) {
-    console.log(JSON.stringify(summary, null, 2));
-  } else {
-    console.log(`# Self-learning benchmark (#2245) — N=${N}`);
-    console.log('');
-    console.log('| Section | Calls | Delta | Passed | Latency (ms) |');
-    console.log('|---|---:|---:|:---:|---:|');
-    console.log(`| A recordSignalProcessed | ${N} | +${summary.sections.A_recordSignalProcessed.signalsProcessedDelta} | ${summary.sections.A_recordSignalProcessed.passed ? '✅' : '❌'} | ${summary.sections.A_recordSignalProcessed.elapsedMs} |`);
-    console.log(`| B task-completed (train) | ${N} | trained=${summary.sections.B_taskCompleted_trainPatterns.trainedViaPipeline}, trajectories+${summary.sections.B_taskCompleted_trainPatterns.trajectoriesDelta} | ${summary.sections.B_taskCompleted_trainPatterns.passed ? '✅' : '❌'} | ${summary.sections.B_taskCompleted_trainPatterns.elapsedMs} (${summary.sections.B_taskCompleted_trainPatterns.avgLatencyMsPerCall}/call) |`);
-    console.log(`| C task-completed (record-only) | ${N} | trajectories+${summary.sections.C_taskCompleted_recordedOnly.trajectoriesDelta} (expected 0) | ${summary.sections.C_taskCompleted_recordedOnly.passed ? '✅' : '❌'} | ${summary.sections.C_taskCompleted_recordedOnly.elapsedMs} |`);
-    console.log(`| D pretrain → neural_patterns | ${items.length} | stored=${summary.sections.D_pretrain_neuralPatterns.stored}, listed=${summary.sections.D_pretrain_neuralPatterns.listTotal} | ${summary.sections.D_pretrain_neuralPatterns.passed ? '✅' : '❌'} | ${summary.sections.D_pretrain_neuralPatterns.elapsedMs} |`);
-    console.log(`| E multi-step trajectory | ${summary.sections.E_multiStepTrajectory.cycles} | persisted=${summary.sections.E_multiStepTrajectory.persistedCount}, sonaUpdate=${summary.sections.E_multiStepTrajectory.sonaUpdateCount} | ${summary.sections.E_multiStepTrajectory.passed ? '✅' : '❌'} | ${summary.sections.E_multiStepTrajectory.elapsedMs} |`);
-    const f = summary.sections.F_unifiedStats;
-    console.log(`| F unified-stats | 4 stores | bridge.reachable=${f.observed['memoryBridge.reachable']}, sona.available=${f.observed['sona.available']}, neural.count=${f.observed['neuralPatterns.patternCount']}, notes=${f.observed['consistency.notes']} | ${f.passed ? '✅' : '❌'} | ${f.elapsedMs} |`);
-    console.log('');
-    console.log(`Final state: signalsProcessed=${summary.finalState.signalsProcessed}, trajectoriesRecorded=${summary.finalState.trajectoriesRecorded}, patternsLearned=${summary.finalState.patternsLearned}`);
-    console.log(`Overall: ${allPassed ? '✅ ALL PASSED' : '❌ FAILED'}`);
-  }
-
-  if (!process.env.BENCH_NO_WRITE) {
-    mkdirSync(RUNS_DIR, { recursive: true });
-    const stamp = summary.runAt.replace(/[:.]/g, '-');
-    writeFileSync(join(RUNS_DIR, `self-learning-${stamp}.json`), JSON.stringify(summary, null, 2));
-    writeFileSync(join(RUNS_DIR, 'self-learning-latest.json'), JSON.stringify(summary, null, 2));
-    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `self-learning-${stamp}.json`)}`);
-  }
-
-  try { rmSync(SCRATCH, { recursive: true, force: true }); } catch {}
-
-  if (!allPassed) process.exit(1);
-}
-
-main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/benchmark-trajectory-mrr.mjs

@@ -1,191 +0,0 @@
-#!/usr/bin/env node
-// benchmark-trajectory-mrr.mjs — proof harness for Structured Distillation
-// (#2241 §SOTA, arXiv:2603.13017).
-//
-// Measures retrieval MRR for raw vs structured-distilled trajectory content
-// against a paired corpus. The arXiv paper reports raw → distilled MRR
-// going from 0.745 to 0.759 on a 214 K-pair consensus-graded set; our corpus
-// is much smaller and hand-curated, so the absolute numbers won't match,
-// but the *direction* of the delta is what we're proving.
-//
-// Two embedders are supported:
-//   - Real ONNX (Xenova/all-MiniLM-L6-v2 384-dim) via @claude-flow/embeddings
-//     when available. Best signal.
-//   - Hash-based deterministic fallback when ONNX isn't installed. Lower
-//     signal; results still relative-comparable.
-//
-// Usage:
-//   node scripts/benchmark-trajectory-mrr.mjs            # default
-//   BENCH_JSON=1 node scripts/benchmark-trajectory-mrr.mjs
-//   BENCH_NO_WRITE=1 node scripts/benchmark-trajectory-mrr.mjs
-
-import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join, resolve } from 'node:path';
-import { performance } from 'node:perf_hooks';
-
-const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(SCRIPT_DIR, '..');
-const REPO_ROOT = resolve(SCRIPT_DIR, '../../../..');
-const RUNS_DIR = join(REPO_ROOT, 'docs', 'benchmarks', 'runs');
-
-const { distillAndSerialise, compressionRatio } = await import(
-  join(CLI_ROOT, 'dist/src/memory/structured-distill.js')
-);
-
-// ---------------------------------------------------------------------------
-// Embedder — prefers real ONNX, falls back to hash-based deterministic.
-// ---------------------------------------------------------------------------
-async function loadEmbedder() {
-  // Tier 1: AgentDB's bridge-loaded ONNX embedder (the path the live MCP
-  // server + vitest tests use, so we measure what users actually get).
-  try {
-    const mb = await import(join(CLI_ROOT, 'dist/src/memory/memory-bridge.js'));
-    const probe = await mb.bridgeGenerateEmbedding('warm-up').catch(() => null);
-    if (probe && probe.embedding && probe.embedding.length > 0 && probe.backend === 'onnx') {
-      return {
-        name: `bridge ONNX (${probe.model}, ${probe.dimensions}-dim)`,
-        embed: async (text) => {
-          const r = await mb.bridgeGenerateEmbedding(text);
-          if (!r) throw new Error('bridge embed returned null');
-          return r.embedding;
-        },
-      };
-    }
-  } catch { /* fall through */ }
-  // Tier 2: hash-based deterministic. Clearly degraded; produces only
-  // direction-of-effect signal, not absolute MRR numbers comparable to paper.
-  console.error('⚠️  Real ONNX embedder unavailable — using hash-based deterministic fallback. Absolute MRR numbers are NOT comparable to the arXiv paper in this mode; relative comparison is also weak.');
-  return {
-    name: 'hash-fallback (no semantic signal — degraded mode)',
-    embed: async (text) => hashEmbed(text, 384),
-  };
-}
-
-function hashEmbed(text, dims) {
-  const v = new Float32Array(dims);
-  let seed = 0;
-  for (let i = 0; i < text.length; i++) seed = (seed * 31 + text.charCodeAt(i)) | 0;
-  let s = Math.abs(seed) | 1;
-  for (let i = 0; i < dims; i++) {
-    s = (s * 1103515245 + 12345) & 0x7fffffff;
-    v[i] = (s / 0x7fffffff) * 2 - 1;
-  }
-  // L2 normalise
-  let n = 0;
-  for (let i = 0; i < dims; i++) n += v[i] * v[i];
-  n = Math.sqrt(n) || 1;
-  for (let i = 0; i < dims; i++) v[i] /= n;
-  return Array.from(v);
-}
-
-function cosine(a, b) {
-  let s = 0;
-  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
-  return s;
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-async function main() {
-  const corpusPath = join(CLI_ROOT, 'bench', 'trajectory-mrr-corpus.json');
-  const corpus = JSON.parse(readFileSync(corpusPath, 'utf-8'));
-  const trajectories = corpus.trajectories;
-  const embedder = await loadEmbedder();
-
-  // Per-trajectory: embed both raw and distilled forms.
-  const tEmbed0 = performance.now();
-  const rawEmbs = [];
-  const distEmbs = [];
-  let totalRawBytes = 0;
-  let totalDistBytes = 0;
-  for (const t of trajectories) {
-    const distilled = distillAndSerialise(t.raw);
-    totalRawBytes += t.raw.length;
-    totalDistBytes += distilled.length;
-    rawEmbs.push(await embedder.embed(t.raw));
-    distEmbs.push(await embedder.embed(distilled));
-  }
-  const embedMs = performance.now() - tEmbed0;
-
-  // For each (query, gold) pair: rank all trajectories by cosine to the query
-  // embedding. MRR = mean of 1 / rank-of-gold across all queries.
-  const tQuery0 = performance.now();
-  let rrRaw = 0, rrDist = 0;
-  const perQuery = [];
-  for (let i = 0; i < trajectories.length; i++) {
-    const q = await embedder.embed(trajectories[i].query);
-    const rankRaw = rankOf(q, rawEmbs, i);
-    const rankDist = rankOf(q, distEmbs, i);
-    rrRaw += 1 / rankRaw;
-    rrDist += 1 / rankDist;
-    perQuery.push({ id: trajectories[i].id, rankRaw, rankDist });
-  }
-  const queryMs = performance.now() - tQuery0;
-
-  const N = trajectories.length;
-  const mrrRaw = rrRaw / N;
-  const mrrDist = rrDist / N;
-  const delta = mrrDist - mrrRaw;
-  const compression = totalRawBytes / Math.max(1, totalDistBytes);
-
-  const summary = {
-    runAt: new Date().toISOString(),
-    benchmark: 'trajectory-mrr',
-    embedder: embedder.name,
-    corpusVersion: corpus.version,
-    corpusSize: N,
-    mrr: {
-      raw: Number(mrrRaw.toFixed(4)),
-      distilled: Number(mrrDist.toFixed(4)),
-      delta: Number(delta.toFixed(4)),
-      paperReference: { raw: 0.745, distilled: 0.759, delta: 0.014, source: 'arXiv:2603.13017' },
-    },
-    compression: {
-      totalRawBytes,
-      totalDistBytes,
-      ratio: Number(compression.toFixed(2)),
-      paperReference: { tokensRaw: 371, tokensDistilled: 38, ratio: 9.76, source: 'arXiv:2603.13017' },
-    },
-    latencyMs: {
-      embedAll: Number(embedMs.toFixed(2)),
-      queryAll: Number(queryMs.toFixed(2)),
-      perDistill: Number((embedMs / (2 * N)).toFixed(4)),
-    },
-    distilledIsBetter: delta > 0,
-    perQueryRanks: perQuery,
-  };
-
-  if (process.env.BENCH_JSON) {
-    console.log(JSON.stringify(summary, null, 2));
-  } else {
-    console.log(`# Trajectory MRR benchmark (#2241 §Structured Distillation)`);
-    console.log(`Embedder: ${embedder.name}`);
-    console.log(`Corpus: N=${N} (v${corpus.version})`);
-    console.log('');
-    console.log('| Metric | Raw | Distilled | Δ |');
-    console.log('|---|---:|---:|---:|');
-    console.log(`| MRR | ${summary.mrr.raw} | ${summary.mrr.distilled} | ${summary.mrr.delta >= 0 ? '+' : ''}${summary.mrr.delta} |`);
-    console.log(`| Total bytes | ${totalRawBytes} | ${totalDistBytes} | ${compression.toFixed(2)}× compression |`);
-    console.log('');
-    console.log(`Distilled is ${summary.distilledIsBetter ? 'BETTER ✅' : 'WORSE ❌'} than raw on this corpus.`);
-    console.log(`Paper (arXiv:2603.13017): MRR raw 0.745 → distilled 0.759 (Δ +0.014); compression ~9.76× (371→38 tokens).`);
-  }
-
-  if (!process.env.BENCH_NO_WRITE) {
-    mkdirSync(RUNS_DIR, { recursive: true });
-    const stamp = summary.runAt.replace(/[:.]/g, '-');
-    writeFileSync(join(RUNS_DIR, `trajectory-mrr-${stamp}.json`), JSON.stringify(summary, null, 2));
-    writeFileSync(join(RUNS_DIR, 'trajectory-mrr-latest.json'), JSON.stringify(summary, null, 2));
-    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `trajectory-mrr-${stamp}.json`)}`);
-  }
-}
-
-function rankOf(query, embeddings, goldIndex) {
-  const scored = embeddings.map((e, i) => ({ i, score: cosine(query, e) }));
-  scored.sort((a, b) => b.score - a.score);
-  return scored.findIndex((s) => s.i === goldIndex) + 1;
-}
-
-main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/deploy-ipfs-node.sh

@@ -1,153 +0,0 @@
-#!/bin/bash
-#
-# Deploy IPFS Node to Google Cloud
-# Provides free IPFS pinning for your users
-#
-# Usage:
-#   ./deploy-ipfs-node.sh [PROJECT_ID] [ZONE]
-#
-# Example:
-#   ./deploy-ipfs-node.sh my-project us-central1-a
-#
-
-set -e
-
-PROJECT_ID="${1:-$(gcloud config get-value project)}"
-ZONE="${2:-us-central1-a}"
-INSTANCE_NAME="ipfs-node"
-MACHINE_TYPE="e2-medium"  # $25/month, use e2-small for $8/month
-DISK_SIZE="100GB"
-
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║  IPFS Node Deployment for Claude Flow                        ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-echo "Project: $PROJECT_ID"
-echo "Zone: $ZONE"
-echo "Machine: $MACHINE_TYPE"
-echo "Disk: $DISK_SIZE"
-echo ""
-
-# Create firewall rules
-echo "▶ Creating firewall rules..."
-gcloud compute firewall-rules create ipfs-swarm \
-  --project="$PROJECT_ID" \
-  --allow=tcp:4001,udp:4001 \
-  --target-tags=ipfs-node \
-  --description="IPFS swarm connections" \
-  2>/dev/null || echo "  (firewall rule already exists)"
-
-gcloud compute firewall-rules create ipfs-api \
-  --project="$PROJECT_ID" \
-  --allow=tcp:5001 \
-  --target-tags=ipfs-node \
-  --source-ranges="0.0.0.0/0" \
-  --description="IPFS API (consider restricting)" \
-  2>/dev/null || echo "  (firewall rule already exists)"
-
-gcloud compute firewall-rules create ipfs-gateway \
-  --project="$PROJECT_ID" \
-  --allow=tcp:8080 \
-  --target-tags=ipfs-node \
-  --description="IPFS Gateway" \
-  2>/dev/null || echo "  (firewall rule already exists)"
-
-# Create startup script
-STARTUP_SCRIPT='#!/bin/bash
-set -e
-
-# Install IPFS
-echo "Installing IPFS..."
-wget -q https://dist.ipfs.tech/kubo/v0.24.0/kubo_v0.24.0_linux-amd64.tar.gz
-tar xzf kubo_v0.24.0_linux-amd64.tar.gz
-cd kubo && sudo bash install.sh
-cd .. && rm -rf kubo kubo_v0.24.0_linux-amd64.tar.gz
-
-# Create ipfs user
-sudo useradd -m -s /bin/bash ipfs || true
-
-# Initialize IPFS
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs init --profile=server
-
-# Configure IPFS for server use
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs config Addresses.API /ip4/0.0.0.0/tcp/5001
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs config Addresses.Gateway /ip4/0.0.0.0/tcp/8080
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs config --json API.HTTPHeaders.Access-Control-Allow-Origin "[\"*\"]"
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs config --json API.HTTPHeaders.Access-Control-Allow-Methods "[\"PUT\", \"POST\", \"GET\"]"
-
-# Set storage limits (adjust as needed)
-sudo -u ipfs IPFS_PATH=/home/ipfs/.ipfs ipfs config Datastore.StorageMax 80GB
-
-# Create systemd service
-cat > /etc/systemd/system/ipfs.service << EOF
-[Unit]
-Description=IPFS Daemon
-After=network.target
-
-[Service]
-Type=simple
-User=ipfs
-Environment=IPFS_PATH=/home/ipfs/.ipfs
-ExecStart=/usr/local/bin/ipfs daemon --migrate=true
-Restart=on-failure
-RestartSec=10
-
-[Install]
-WantedBy=multi-user.target
-EOF
-
-# Start IPFS
-systemctl daemon-reload
-systemctl enable ipfs
-systemctl start ipfs
-
-echo "IPFS node started successfully!"
-'
-
-# Create instance
-echo "▶ Creating VM instance..."
-gcloud compute instances create "$INSTANCE_NAME" \
-  --project="$PROJECT_ID" \
-  --zone="$ZONE" \
-  --machine-type="$MACHINE_TYPE" \
-  --image-family=ubuntu-2204-lts \
-  --image-project=ubuntu-os-cloud \
-  --boot-disk-size="$DISK_SIZE" \
-  --boot-disk-type=pd-ssd \
-  --tags=ipfs-node \
-  --metadata=startup-script="$STARTUP_SCRIPT"
-
-# Get external IP
-echo ""
-echo "▶ Waiting for instance to start..."
-sleep 30
-
-EXTERNAL_IP=$(gcloud compute instances describe "$INSTANCE_NAME" \
-  --project="$PROJECT_ID" \
-  --zone="$ZONE" \
-  --format='get(networkInterfaces[0].accessConfigs[0].natIP)')
-
-echo ""
-echo "═══════════════════════════════════════════════════════════════"
-echo "                    DEPLOYMENT COMPLETE"
-echo "═══════════════════════════════════════════════════════════════"
-echo ""
-echo "  IPFS Node IP: $EXTERNAL_IP"
-echo ""
-echo "  Endpoints:"
-echo "    API:     http://$EXTERNAL_IP:5001"
-echo "    Gateway: http://$EXTERNAL_IP:8080"
-echo "    Swarm:   /ip4/$EXTERNAL_IP/tcp/4001"
-echo ""
-echo "  Test commands:"
-echo "    curl http://$EXTERNAL_IP:5001/api/v0/id"
-echo "    curl http://$EXTERNAL_IP:8080/ipfs/QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG/readme"
-echo ""
-echo "  Configure Claude Flow CLI:"
-echo "    export IPFS_API_URL=http://$EXTERNAL_IP:5001"
-echo ""
-echo "  SSH into node:"
-echo "    gcloud compute ssh $INSTANCE_NAME --zone=$ZONE"
-echo ""
-echo "  Monthly cost estimate: ~\$25-54 depending on usage"
-echo ""