@swarmdo/cli 1.4.8

package/scripts/pretrain-from-github.mjs

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+// pretrain-from-github.mjs — pretrain swarmdo's self-learning system from its
+// own GitHub history (commits + issues). Each commit/issue becomes one
+// trajectory through the SONA + EWC++ pipeline; Structured Distillation
+// (ADR-076) compresses each into the 4-field schema before embedding.
+//
+// What this proves:
+//   - globalStats.{trajectoriesRecorded, patternsLearned, signalsProcessed}
+//     all move from a measured before to a measured after.
+//   - neural_patterns.patternCount grows.
+//   - memory-bridge entries grow.
+//   - The unified-stats aggregator's consistency block stays clean.
+//   - Every item gets a learningPath of 'trajectory-pipeline' (not 'recorded-only').
+//
+// Usage:
+//   node scripts/pretrain-from-github.mjs                   # 50 commits + 30 issues
+//   COMMITS=200 ISSUES=100 node scripts/pretrain-from-github.mjs
+//   SOURCE=git node scripts/pretrain-from-github.mjs        # git only, skip gh
+//   BENCH_JSON=1 node scripts/pretrain-from-github.mjs      # machine-readable
+//   BENCH_NO_WRITE=1 node scripts/pretrain-from-github.mjs  # don't write a run JSON
+//
+// Repro from a fresh checkout:
+//   git clone the upstream project (see NOTICE) && cd swarmdo
+//   npm install && ( cd v3/@swarmdo/cli && npx tsc -b )
+//   node v3/@swarmdo/cli/scripts/pretrain-from-github.mjs
+
+import { execSync } from 'node:child_process';
+import { 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 SWARMDO_ROOT = resolve(SCRIPT_DIR, '../../../..');
+const RUNS_DIR = join(SWARMDO_ROOT, 'docs', 'benchmarks', 'runs');
+
+// ADR-084 cross-repo support — REPO_ROOT and GH_REPO env-overridable so the
+// same script can pretrain on agentdb / agentic-flow / any other repo for
+// generalisation testing. Defaults preserve swarmdo behaviour.
+const REPO_ROOT = process.env.REPO_ROOT ? resolve(process.env.REPO_ROOT) : SWARMDO_ROOT;
+const GH_REPO   = process.env.GH_REPO   || 'upstream/swarmdo';
+
+const COMMITS = Number(process.env.COMMITS) || 50;
+const ISSUES  = Number(process.env.ISSUES)  || 30;
+const SOURCE  = process.env.SOURCE || 'all'; // 'all' | 'git' | 'issues'
+
+// ---------------------------------------------------------------------------
+// Harvesters
+// ---------------------------------------------------------------------------
+
+// ADR-078 outcome signal — classify each commit by whether it was reverted,
+// hotfix-followed, or stuck. Operates on the harvested-commits window plus a
+// wider lookahead window for revert/hotfix detection.
+//
+// Verdicts emitted:
+//   success — landed cleanly, no later commit reverted or fixed it
+//   reverted — a later commit subject starts with `Revert "<this subject>"`
+//   hotfixed — a later commit (within HOTFIX_WINDOW_COMMITS) shares >=50%
+//              of the same touched files AND subject contains fix|hotfix|patch
+//
+// The "later" direction is git-log order (newest first → we look at older
+// indices in the lookahead, which are NEWER commits chronologically).
+const HOTFIX_WINDOW_COMMITS = Number(process.env.HOTFIX_WINDOW_COMMITS) || 20;
+const HOTFIX_FILE_OVERLAP = Number(process.env.HOTFIX_FILE_OVERLAP) || 0.5;
+const HOTFIX_KEYWORDS = /\b(fix|hotfix|patch|revert|bugfix|fixup)\b/i;
+
+function harvestCommits(n) {
+  if (SOURCE === 'issues') return [];
+  const fmt = '%H%x00%s%x00%b%x01';
+  // Pull a wider window so we have lookahead for revert/hotfix detection
+  // without changing the trained set size n.
+  const lookahead = HOTFIX_WINDOW_COMMITS;
+  const raw = execSync(
+    `git log --pretty=format:'${fmt}' -n ${n + lookahead} 2>/dev/null`,
+    { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },
+  );
+
+  // Parse all blocks (window + lookahead).
+  const all = [];
+  for (const block of raw.split('\x01')) {
+    if (!block.trim()) continue;
+    const [sha, subject, body] = block.split('\x00');
+    if (!sha || !subject) continue;
+    all.push({ sha, subject: subject.trim(), body: (body || '').trim() });
+  }
+
+  // For each commit in the trained slice, get its touched files.
+  const filesCache = new Map();
+  const filesOf = (sha) => {
+    if (filesCache.has(sha)) return filesCache.get(sha);
+    try {
+      const out = execSync(
+        `git show --pretty=format: --name-only ${sha} 2>/dev/null`,
+        { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 8 * 1024 * 1024 },
+      ).trim().split('\n').filter(Boolean);
+      filesCache.set(sha, new Set(out));
+      return filesCache.get(sha);
+    } catch {
+      filesCache.set(sha, new Set());
+      return filesCache.get(sha);
+    }
+  };
+
+  // Build a revert-target map: any commit whose subject starts with
+  // `Revert "<X>"` flags X as reverted.
+  const revertedSubjects = new Set();
+  for (const c of all) {
+    const m = c.subject.match(/^Revert\s+"(.+?)"/);
+    if (m) revertedSubjects.add(m[1].trim());
+  }
+
+  const trained = all.slice(0, n);
+  const entries = [];
+  for (let i = 0; i < trained.length; i++) {
+    const c = trained[i];
+    const myFiles = filesOf(c.sha);
+
+    let verdict = 'success';
+    let outcomeNote = null;
+
+    // Reverted? Check if any later (lower-index = newer) commit reverted us.
+    if (revertedSubjects.has(c.subject)) {
+      verdict = 'reverted';
+      outcomeNote = 'subject reverted by a later commit';
+    } else {
+      // Hotfixed? A later commit within HOTFIX_WINDOW_COMMITS shares files
+      // AND has fix/hotfix in its subject.
+      const start = Math.max(0, i - HOTFIX_WINDOW_COMMITS);
+      for (let j = start; j < i; j++) {
+        const later = trained[j];
+        if (!HOTFIX_KEYWORDS.test(later.subject)) continue;
+        const laterFiles = filesOf(later.sha);
+        if (laterFiles.size === 0 || myFiles.size === 0) continue;
+        let overlap = 0;
+        for (const f of laterFiles) if (myFiles.has(f)) overlap++;
+        // Use min() so a small targeted fix on a big change still triggers
+        // (semantic: "≥half of the smaller commit's files overlap").
+        const overlapFrac = overlap / Math.min(laterFiles.size, myFiles.size);
+        if (overlapFrac >= HOTFIX_FILE_OVERLAP) {
+          verdict = 'hotfixed';
+          outcomeNote = `${(overlapFrac * 100).toFixed(0)}% file overlap with later fix ${later.sha.slice(0, 8)}`;
+          break;
+        }
+      }
+    }
+
+    entries.push({
+      source: 'commit',
+      id: `commit-${c.sha.slice(0, 12)}`,
+      subject: c.subject,
+      body: c.body,
+      verdict,
+      outcomeNote,
+      content: `${c.subject}\n\n${c.body}`.slice(0, 8192),
+    });
+  }
+  return entries;
+}
+
+function harvestIssues(n) {
+  if (SOURCE === 'git') return [];
+  try {
+    const raw = execSync(
+      `gh issue list --repo ${GH_REPO} --state all --limit ${n} --json number,title,body,state,closedAt 2>/dev/null`,
+      { cwd: REPO_ROOT, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 },
+    );
+    const items = JSON.parse(raw);
+    return items.map((i) => ({
+      source: 'issue',
+      id: `issue-${i.number}`,
+      subject: i.title,
+      body: (i.body || '').slice(0, 8192),
+      // closed = success outcome; open = partial (in-progress).
+      verdict: i.state === 'CLOSED' ? 'success' : 'partial',
+      content: `${i.title}\n\n${(i.body || '').slice(0, 8192)}`,
+    }));
+  } catch (err) {
+    console.error(`gh issue harvest skipped (${err.message?.slice(0, 60)}). Set SOURCE=git to silence.`);
+    return [];
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const intel = await import(join(CLI_ROOT, 'dist/src/memory/intelligence.js'));
+  const neural = await import(join(CLI_ROOT, 'dist/src/mcp-tools/neural-tools.js'));
+  const { distillAndSerialise } = await import(join(CLI_ROOT, 'dist/src/memory/structured-distill.js'));
+
+  // §1 — record the baseline (no clear; we want to learn ON TOP of whatever
+  // history the user already has).
+  const unified0 = await intel.getUnifiedLearningStats();
+  const before = {
+    trajectoriesRecorded: unified0.global.trajectoriesRecorded,
+    patternsLearned: unified0.global.patternsLearned,
+    signalsProcessed: unified0.global.signalsProcessed,
+    neuralPatternCount: unified0.neuralPatterns.patternCount,
+    memoryBridgeTotal: unified0.memoryBridge.totalEntries,
+  };
+
+  // §2 — harvest
+  const tHarvest0 = performance.now();
+  const commits = harvestCommits(COMMITS);
+  const issues = harvestIssues(ISSUES);
+  const items = [...commits, ...issues];
+  const harvestMs = performance.now() - tHarvest0;
+
+  if (!process.env.BENCH_JSON) {
+    console.log(`# Pretrain from swarmdo GitHub history`);
+    console.log(`Harvested: ${commits.length} commits + ${issues.length} issues = ${items.length} trajectories (${harvestMs.toFixed(0)} ms)`);
+  }
+
+  // §3 — feed each item through the trajectory pipeline. The harvester
+  // emits one of: success | partial | reverted | hotfixed. We map this to
+  // the trajectory pipeline's binary verdict {success, partial} since the
+  // pipeline doesn't accept arbitrary strings — but we preserve the original
+  // outcome in metadata + the summary's verdictMix so the signal isn't lost.
+  const verdictToPipeline = (v) => {
+    if (v === 'success') return 'success';
+    if (v === 'partial') return 'partial';
+    if (v === 'reverted') return 'partial';   // a revert is the strongest "this was wrong" signal we have
+    if (v === 'hotfixed') return 'partial';   // a same-files fix-followup is "needs adjustment"
+    return 'success';
+  };
+  const verdictMix = { success: 0, partial: 0, reverted: 0, hotfixed: 0 };
+  const tFeed0 = performance.now();
+  let trained = 0;
+  let failed = 0;
+  const failures = [];
+  for (const item of items) {
+    try {
+      const distilled = distillAndSerialise(item.content);
+      verdictMix[item.verdict] = (verdictMix[item.verdict] ?? 0) + 1;
+      await intel.recordTrajectory(
+        [{
+          type: 'result',
+          content: distilled,
+          metadata: {
+            source: item.source,
+            id: item.id,
+            subject: item.subject.slice(0, 200),
+            outcomeVerdict: item.verdict,
+            outcomeNote: item.outcomeNote ?? null,
+          },
+          timestamp: Date.now(),
+        }],
+        verdictToPipeline(item.verdict),
+      );
+      trained++;
+    } catch (err) {
+      failed++;
+      if (failures.length < 5) failures.push({ id: item.id, error: String(err.message).slice(0, 120) });
+    }
+  }
+  const feedMs = performance.now() - tFeed0;
+  intel.flushIntelligenceStats();
+
+  // §4 — also seed the neural store directly from the same items so
+  // `neural_patterns list` reflects them (closes the "globalStats moved but
+  // neural_patterns didn't" consistency note from ADR-075).
+  const tSeed0 = performance.now();
+  const neuralItems = items.map((item) => ({
+    name: item.subject.slice(0, 200),
+    type: item.source === 'commit' ? 'history-commit' : 'history-issue',
+    content: distillAndSerialise(item.content),
+    metadata: { source: item.source, id: item.id, verdict: item.verdict },
+  }));
+  const seedResult = await neural.storeNeuralPatterns(neuralItems);
+  const seedMs = performance.now() - tSeed0;
+
+  // §5 — read the after-counters via the unified aggregator (this is what
+  // hooks_intelligence_unified-stats would return for a live caller).
+  const unified1 = await intel.getUnifiedLearningStats();
+  const after = {
+    trajectoriesRecorded: unified1.global.trajectoriesRecorded,
+    patternsLearned: unified1.global.patternsLearned,
+    signalsProcessed: unified1.global.signalsProcessed,
+    neuralPatternCount: unified1.neuralPatterns.patternCount,
+    memoryBridgeTotal: unified1.memoryBridge.totalEntries,
+  };
+
+  const deltas = Object.fromEntries(
+    Object.keys(after).map((k) => [k, after[k] - before[k]]),
+  );
+
+  const summary = {
+    runAt: new Date().toISOString(),
+    benchmark: 'pretrain-from-github',
+    source: SOURCE,
+    config: { COMMITS, ISSUES },
+    harvest: {
+      commits: commits.length,
+      issues: issues.length,
+      total: items.length,
+      harvestMs: Number(harvestMs.toFixed(2)),
+    },
+    feed: {
+      trained,
+      failed,
+      avgLatencyMs: items.length > 0 ? Number((feedMs / items.length).toFixed(2)) : 0,
+      totalMs: Number(feedMs.toFixed(2)),
+      sampleFailures: failures,
+      verdictMix,   // ADR-078 outcome signal — counts per harvested verdict
+    },
+    seedNeuralStore: {
+      stored: seedResult.stored,
+      total: seedResult.total,
+      seedMs: Number(seedMs.toFixed(2)),
+    },
+    before,
+    after,
+    deltas,
+    consistency: unified1.consistency,
+    passed:
+      trained === items.length &&
+      deltas.trajectoriesRecorded >= items.length &&
+      deltas.neuralPatternCount >= items.length,
+  };
+
+  if (process.env.BENCH_JSON) {
+    console.log(JSON.stringify(summary, null, 2));
+  } else {
+    console.log('');
+    console.log('| Counter | Before | After | Δ |');
+    console.log('|---|---:|---:|---:|');
+    for (const k of Object.keys(after)) {
+      console.log(`| ${k} | ${before[k]} | ${after[k]} | +${deltas[k]} |`);
+    }
+    console.log('');
+    console.log(`Trained via trajectory pipeline: ${trained}/${items.length}`);
+    console.log(`Failed: ${failed}`);
+    console.log(`Avg latency per trajectory: ${summary.feed.avgLatencyMs} ms`);
+    console.log(`Neural store seeded: ${seedResult.stored}/${seedResult.total}`);
+    console.log(`Verdict mix: success=${verdictMix.success} partial=${verdictMix.partial} reverted=${verdictMix.reverted} hotfixed=${verdictMix.hotfixed}`);
+    console.log(`Overall: ${summary.passed ? '✅ PASSED' : '⚠️  partial'}`);
+    if (unified1.consistency.notes.length > 0) {
+      console.log(`\nConsistency notes:`);
+      for (const n of unified1.consistency.notes) console.log(`  • ${n}`);
+    }
+  }
+
+  if (!process.env.BENCH_NO_WRITE) {
+    mkdirSync(RUNS_DIR, { recursive: true });
+    const stamp = summary.runAt.replace(/[:.]/g, '-');
+    writeFileSync(join(RUNS_DIR, `pretrain-from-github-${stamp}.json`), JSON.stringify(summary, null, 2));
+    writeFileSync(join(RUNS_DIR, 'pretrain-from-github-latest.json'), JSON.stringify(summary, null, 2));
+    if (!process.env.BENCH_JSON) console.log(`\nWrote ${join(RUNS_DIR, `pretrain-from-github-${stamp}.json`)}`);
+  }
+
+  // ONNX runtime keeps a worker thread alive — force exit so this can be used
+  // as a CI step or chained with other scripts.
+  process.exit(summary.passed ? 0 : 1);
+}
+
+main().catch((err) => { console.error(err); process.exit(1); });

package/scripts/publish-registry.ts

@@ -0,0 +1,345 @@
+#!/usr/bin/env npx tsx
+/**
+ * Plugin Registry Publisher
+ *
+ * Publishes the plugin registry to IPFS via Pinata and updates IPNS pointer.
+ *
+ * Setup:
+ * 1. Create Pinata account at https://pinata.cloud
+ * 2. Generate API keys (JWT)
+ * 3. Set environment variables:
+ *    - PINATA_JWT: Your Pinata JWT token
+ *    - REGISTRY_PRIVATE_KEY: Ed25519 private key (hex) for signing
+ *
+ * Usage:
+ *   npx tsx scripts/publish-registry.ts
+ *   npx tsx scripts/publish-registry.ts --dry-run
+ *   npx tsx scripts/publish-registry.ts --registry ./custom-registry.json
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Types
+interface PluginEntry {
+  id: string;
+  name: string;
+  displayName: string;
+  description: string;
+  version: string;
+  cid?: string;
+  size: number;
+  checksum: string;
+  author: {
+    id: string;
+    displayName: string;
+    verified: boolean;
+  };
+  license: string;
+  categories: string[];
+  tags: string[];
+  downloads: number;
+  rating: number;
+  lastUpdated: string;
+  minClaudeFlowVersion: string;
+  type: string;
+  hooks: string[];
+  commands: string[];
+  permissions: string[];
+  exports: string[];
+  verified: boolean;
+  trustLevel: string;
+}
+
+interface PluginRegistry {
+  version: string;
+  type: 'plugins';
+  updatedAt: string;
+  ipnsName: string;
+  plugins: PluginEntry[];
+  categories: Array<{ id: string; name: string; description: string; pluginCount: number }>;
+  totalPlugins: number;
+  totalDownloads: number;
+  featured: string[];
+  trending: string[];
+  newest: string[];
+  official: string[];
+  registrySignature?: string;
+  registryPublicKey?: string;
+}
+
+interface PinataResponse {
+  IpfsHash: string;
+  PinSize: number;
+  Timestamp: string;
+}
+
+// Configuration
+const PINATA_API_URL = 'https://api.pinata.cloud';
+const DEFAULT_REGISTRY_PATH = path.join(__dirname, '../src/plugins/store/registry.json');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const isDryRun = args.includes('--dry-run');
+const registryPathArg = args.find(a => a.startsWith('--registry='));
+const registryPath = registryPathArg
+  ? registryPathArg.split('=')[1]
+  : DEFAULT_REGISTRY_PATH;
+
+/**
+ * Fetch npm stats for a package
+ */
+async function fetchNpmStats(packageName: string): Promise<{ downloads: number; version: string } | null> {
+  try {
+    const downloadsUrl = `https://api.npmjs.org/downloads/point/last-week/${encodeURIComponent(packageName)}`;
+    const downloadsRes = await fetch(downloadsUrl, { signal: AbortSignal.timeout(5000) });
+
+    if (!downloadsRes.ok) return null;
+
+    const downloadsData = await downloadsRes.json() as { downloads?: number };
+
+    const packageUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+    const packageRes = await fetch(packageUrl, { signal: AbortSignal.timeout(5000) });
+
+    let version = 'unknown';
+    if (packageRes.ok) {
+      const packageData = await packageRes.json() as { version?: string };
+      version = packageData.version || 'unknown';
+    }
+
+    return {
+      downloads: downloadsData.downloads || 0,
+      version,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Sign registry with Ed25519
+ */
+async function signRegistry(registry: PluginRegistry, privateKeyHex: string): Promise<{
+  signature: string;
+  publicKey: string;
+}> {
+  const ed = await import('@noble/ed25519');
+
+  const privateKey = Buffer.from(privateKeyHex, 'hex');
+  const publicKey = await ed.getPublicKeyAsync(privateKey);
+
+  // Create a copy without signature fields for signing
+  const registryToSign = { ...registry };
+  delete registryToSign.registrySignature;
+  delete registryToSign.registryPublicKey;
+
+  const message = JSON.stringify(registryToSign);
+  const signature = await ed.signAsync(
+    new TextEncoder().encode(message),
+    privateKey
+  );
+
+  return {
+    signature: Buffer.from(signature).toString('hex'),
+    publicKey: `ed25519:${Buffer.from(publicKey).toString('hex')}`,
+  };
+}
+
+/**
+ * Pin JSON to IPFS via Pinata
+ */
+async function pinToIPFS(data: unknown, name: string, jwt: string): Promise<PinataResponse> {
+  const response = await fetch(`${PINATA_API_URL}/pinning/pinJSONToIPFS`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${jwt}`,
+    },
+    body: JSON.stringify({
+      pinataContent: data,
+      pinataMetadata: {
+        name,
+        keyvalues: {
+          type: 'plugin-registry',
+          publishedAt: new Date().toISOString(),
+        },
+      },
+      pinataOptions: {
+        cidVersion: 1,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Pinata error: ${response.status} - ${error}`);
+  }
+
+  return response.json() as Promise<PinataResponse>;
+}
+
+/**
+ * Generate a demo registry from npm packages
+ */
+async function generateRegistry(): Promise<PluginRegistry> {
+  console.log('📦 Fetching npm stats for plugins...');
+
+  const officialPackages = [
+    '@swarmdo/plugin-agentic-qe',
+    '@swarmdo/plugin-prime-radiant',
+    '@swarmdo/plugin-gastown-bridge',
+    '@swarmdo/security',
+    '@swarmdo/claims',
+    '@swarmdo/embeddings',
+    '@swarmdo/neural',
+    '@swarmdo/performance',
+    '@swarmdo/plugins',
+  ];
+
+  const plugins: PluginEntry[] = [];
+  const now = new Date().toISOString();
+
+  for (const pkg of officialPackages) {
+    console.log(`  Fetching ${pkg}...`);
+    const stats = await fetchNpmStats(pkg);
+
+    plugins.push({
+      id: pkg,
+      name: pkg,
+      displayName: pkg.replace('@swarmdo/plugin-', '').replace('@swarmdo/', ''),
+      description: `Official Swarmdo plugin: ${pkg}`,
+      version: stats?.version || '0.0.0',
+      size: 100000,
+      checksum: `sha256:${crypto.randomBytes(32).toString('hex')}`,
+      author: {
+        id: 'swarmdo-team',
+        displayName: 'Swarmdo Team',
+        verified: true,
+      },
+      license: 'MIT',
+      categories: ['official'],
+      tags: [pkg.split('/').pop() || ''],
+      downloads: stats?.downloads || 0,
+      rating: 0,
+      lastUpdated: now,
+      minClaudeFlowVersion: '3.0.0',
+      type: 'integration',
+      hooks: [],
+      commands: [],
+      permissions: ['memory', 'filesystem'],
+      exports: [],
+      verified: true,
+      trustLevel: 'official',
+    });
+  }
+
+  const totalDownloads = plugins.reduce((sum, p) => sum + p.downloads, 0);
+
+  return {
+    version: '1.0.0',
+    type: 'plugins',
+    updatedAt: now,
+    ipnsName: '', // Will be set after publishing
+    plugins,
+    categories: [
+      { id: 'official', name: 'Official', description: 'Official Swarmdo plugins', pluginCount: plugins.length },
+    ],
+    totalPlugins: plugins.length,
+    totalDownloads,
+    featured: plugins.slice(0, 3).map(p => p.id),
+    trending: plugins.sort((a, b) => b.downloads - a.downloads).slice(0, 3).map(p => p.id),
+    newest: plugins.slice(-3).map(p => p.id),
+    official: plugins.map(p => p.id),
+  };
+}
+
+/**
+ * Main publish function
+ */
+async function main() {
+  console.log('🚀 Plugin Registry Publisher\n');
+
+  // Check environment
+  const jwt = process.env.PINATA_JWT;
+  const privateKey = process.env.REGISTRY_PRIVATE_KEY;
+
+  if (!jwt) {
+    console.error('❌ PINATA_JWT environment variable is required');
+    console.log('\nGet your JWT from https://pinata.cloud/keys');
+    process.exit(1);
+  }
+
+  // Load or generate registry
+  let registry: PluginRegistry;
+
+  if (fs.existsSync(registryPath)) {
+    console.log(`📄 Loading registry from ${registryPath}`);
+    const content = fs.readFileSync(registryPath, 'utf-8');
+    registry = JSON.parse(content);
+  } else {
+    console.log('📄 Generating registry from npm packages...');
+    registry = await generateRegistry();
+  }
+
+  // Update timestamp
+  registry.updatedAt = new Date().toISOString();
+
+  console.log(`\n📊 Registry Stats:`);
+  console.log(`   Plugins: ${registry.plugins.length}`);
+  console.log(`   Total Downloads: ${registry.totalDownloads.toLocaleString()}`);
+  console.log(`   Updated: ${registry.updatedAt}`);
+
+  // Sign registry if private key is available
+  if (privateKey) {
+    console.log('\n🔐 Signing registry with Ed25519...');
+    const { signature, publicKey } = await signRegistry(registry, privateKey);
+    registry.registrySignature = signature;
+    registry.registryPublicKey = publicKey;
+    console.log(`   Public Key: ${publicKey.slice(0, 30)}...`);
+  } else {
+    console.log('\n⚠️  No REGISTRY_PRIVATE_KEY set, skipping signature');
+  }
+
+  if (isDryRun) {
+    console.log('\n🔍 Dry run - would publish:');
+    console.log(JSON.stringify(registry, null, 2).slice(0, 1000) + '...');
+    return;
+  }
+
+  // Pin to IPFS
+  console.log('\n📌 Pinning to IPFS via Pinata...');
+  try {
+    const result = await pinToIPFS(registry, 'swarmdo-plugin-registry', jwt);
+
+    console.log('\n✅ Published successfully!');
+    console.log(`   CID: ${result.IpfsHash}`);
+    console.log(`   Size: ${(result.PinSize / 1024).toFixed(2)} KB`);
+    console.log(`\n🌐 Gateway URLs:`);
+    console.log(`   https://gateway.pinata.cloud/ipfs/${result.IpfsHash}`);
+    console.log(`   https://ipfs.io/ipfs/${result.IpfsHash}`);
+    console.log(`   https://cloudflare-ipfs.com/ipfs/${result.IpfsHash}`);
+    console.log(`   https://dweb.link/ipfs/${result.IpfsHash}`);
+
+    // Save CID for reference
+    const cidFile = path.join(__dirname, '../.registry-cid');
+    fs.writeFileSync(cidFile, result.IpfsHash);
+    console.log(`\n💾 CID saved to ${cidFile}`);
+
+    // Update discovery.ts config (manual step reminder)
+    console.log('\n📝 Next steps:');
+    console.log('   1. Update DEFAULT_PLUGIN_STORE_CONFIG in discovery.ts with the new CID');
+    console.log('   2. If using IPNS, update the IPNS pointer via Pinata dashboard');
+    console.log('   3. Test with: npx swarmdo@latest plugins list');
+  } catch (error) {
+    console.error('\n❌ Publish failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run
+main().catch(console.error);