@xnetjs/cli 0.0.2

package/dist/cli.js

@@ -0,0 +1,890 @@
+#!/usr/bin/env node
+import {
+  diffSchemas,
+  generateLensCode,
+  generateLensSnippet
+} from "./chunk-IUOECMVU.js";
+
+// src/cli.ts
+import { program } from "commander";
+
+// src/commands/doctor.ts
+import { writeFileSync, readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { resolve, join } from "path";
+import {
+  verifyIntegrity,
+  quickIntegrityCheck,
+  attemptRepair,
+  findOrphans,
+  findRoots,
+  findHeads,
+  getChainDepth
+} from "@xnetjs/sync";
+async function getChalk() {
+  try {
+    const chalk = await import("chalk");
+    return chalk.default;
+  } catch {
+    const identity = (s) => s;
+    return {
+      green: identity,
+      yellow: identity,
+      red: identity,
+      blue: identity,
+      gray: identity,
+      cyan: identity,
+      bold: identity,
+      dim: identity
+    };
+  }
+}
+function findDataDir(providedDir) {
+  if (providedDir) {
+    const resolved = resolve(process.cwd(), providedDir);
+    if (existsSync(resolved)) {
+      return resolved;
+    }
+    throw new Error(`Data directory not found: ${resolved}`);
+  }
+  const commonPaths = [".xnet/data", "data", ".data", resolve(process.env.HOME ?? "", ".xnet/data")];
+  for (const path of commonPaths) {
+    const resolved = resolve(process.cwd(), path);
+    if (existsSync(resolved)) {
+      return resolved;
+    }
+  }
+  throw new Error("Could not find data directory. Use --data-dir to specify location.");
+}
+function loadChangesFromDir(dataDir) {
+  const changes = [];
+  const patterns = ["changes.json", "changes/*.json", "*.changes.json"];
+  for (const pattern of patterns) {
+    const changesFile = join(dataDir, pattern.split("/")[0]);
+    if (existsSync(changesFile) && statSync(changesFile).isFile()) {
+      try {
+        const content = readFileSync(changesFile, "utf-8");
+        const data = JSON.parse(content);
+        if (Array.isArray(data)) {
+          changes.push(...data);
+        } else if (data.changes && Array.isArray(data.changes)) {
+          changes.push(...data.changes);
+        }
+      } catch {
+      }
+    }
+  }
+  const changesDir = join(dataDir, "changes");
+  if (existsSync(changesDir) && statSync(changesDir).isDirectory()) {
+    const files = readdirSync(changesDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(changesDir, file), "utf-8");
+        const change = JSON.parse(content);
+        changes.push(change);
+      } catch {
+      }
+    }
+  }
+  return changes;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+async function doctorCommand(options) {
+  const chalk = await getChalk();
+  console.log(chalk.bold("\nxNet Health Check\n"));
+  console.log(chalk.dim("\u2500".repeat(50)));
+  try {
+    let dataDir;
+    let changes = [];
+    try {
+      dataDir = findDataDir(options.dataDir);
+      console.log(chalk.gray(`Data directory: ${dataDir}`));
+      changes = loadChangesFromDir(dataDir);
+      console.log(chalk.gray(`Found ${changes.length} changes`));
+    } catch {
+      console.log(chalk.yellow("\nNote: No data directory found."));
+      console.log(chalk.gray("Use --data-dir to specify a data directory."));
+      console.log(chalk.gray("Running with demo data...\n"));
+      changes = generateDemoChanges();
+    }
+    console.log();
+    console.log(chalk.bold("Checking data integrity..."));
+    const report = options.quick ? await quickIntegrityCheck(changes) : await verifyIntegrity(changes);
+    if (options.json) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    printIntegrityResults(report, chalk, options.verbose);
+    console.log();
+    console.log(chalk.bold("Analyzing change chains..."));
+    const orphans = findOrphans(changes);
+    const roots = findRoots(changes);
+    const heads = findHeads(changes);
+    const depth = getChainDepth(changes);
+    console.log(`  ${chalk.green("\u2713")} Roots: ${roots.length}`);
+    console.log(`  ${chalk.green("\u2713")} Heads: ${heads.length}`);
+    console.log(`  ${chalk.green("\u2713")} Depth: ${depth}`);
+    if (orphans.length > 0) {
+      console.log(`  ${chalk.yellow("\u26A0")} Orphans: ${orphans.length}`);
+    } else {
+      console.log(`  ${chalk.green("\u2713")} Orphans: 0`);
+    }
+    console.log();
+    console.log(chalk.bold("Checking schema compatibility..."));
+    console.log(chalk.gray("  (Schema analysis requires @xnetjs/data integration)"));
+    console.log();
+    console.log(chalk.bold("Checking sync state..."));
+    console.log(chalk.gray("  (Sync analysis requires active SyncProvider)"));
+    console.log();
+    console.log(chalk.dim("\u2500".repeat(50)));
+    const hasErrors = report.summary.errors > 0;
+    const hasWarnings = report.summary.warnings > 0 || orphans.length > 0;
+    if (hasErrors) {
+      console.log(chalk.red(chalk.bold("Status: UNHEALTHY")));
+      console.log(chalk.red("  Data integrity issues detected. Run `xnet repair` to fix."));
+    } else if (hasWarnings) {
+      console.log(chalk.yellow(chalk.bold("Status: HEALTHY with warnings")));
+      console.log(chalk.gray("  Some issues detected but data is intact."));
+    } else {
+      console.log(chalk.green(chalk.bold("Status: HEALTHY")));
+      console.log(chalk.green("  All checks passed."));
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+function printIntegrityResults(report, chalk, verbose) {
+  const { checked, valid, issues, summary, durationMs } = report;
+  const percentage = checked > 0 ? Math.round(valid / checked * 100) : 100;
+  if (issues.length === 0) {
+    console.log(`  ${chalk.green("\u2713")} ${checked} changes verified (${percentage}% valid)`);
+    console.log(`  ${chalk.green("\u2713")} Hash chains intact`);
+    console.log(`  ${chalk.green("\u2713")} No issues detected`);
+    console.log(chalk.gray(`  Completed in ${formatDuration(durationMs)}`));
+  } else {
+    console.log(
+      `  ${chalk.yellow("!")} ${checked} changes checked (${valid} valid, ${checked - valid} issues)`
+    );
+    if (summary.errors > 0) {
+      console.log(`  ${chalk.red("\u2717")} ${summary.errors} errors`);
+    }
+    if (summary.warnings > 0) {
+      console.log(`  ${chalk.yellow("\u26A0")} ${summary.warnings} warnings`);
+    }
+    console.log(chalk.gray(`  Completed in ${formatDuration(durationMs)}`));
+    if (verbose) {
+      console.log();
+      console.log(chalk.bold("Issues by type:"));
+      for (const [type, count] of Object.entries(summary.byType)) {
+        if (count > 0) {
+          console.log(`  - ${type}: ${count}`);
+        }
+      }
+      console.log();
+      console.log(chalk.bold("Details:"));
+      for (const issue of issues.slice(0, 10)) {
+        const icon = issue.severity === "error" ? chalk.red("\u2717") : chalk.yellow("\u26A0");
+        console.log(`  ${icon} [${issue.type}] ${issue.details}`);
+        if (issue.repairAction) {
+          console.log(chalk.gray(`      \u2192 ${issue.repairAction.description}`));
+        }
+      }
+      if (issues.length > 10) {
+        console.log(chalk.gray(`  ... and ${issues.length - 10} more`));
+      }
+    }
+    if (report.repairable) {
+      console.log();
+      console.log(chalk.cyan(`  Run \`xnet repair\` to fix these issues.`));
+    }
+  }
+}
+function generateDemoChanges() {
+  const now = Date.now();
+  const demoAuthor = "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK";
+  const demoHash1 = "cid:blake3:0000000000000000000000000000000000000000000000000000000000000001";
+  const demoHash2 = "cid:blake3:0000000000000000000000000000000000000000000000000000000000000002";
+  return [
+    {
+      id: "change-1",
+      protocolVersion: 1,
+      type: "create-node",
+      payload: { schemaIRI: "xnet://xnet.fyi/Task@1.0.0" },
+      hash: demoHash1,
+      parentHash: null,
+      authorDID: demoAuthor,
+      signature: new Uint8Array([1, 2, 3, 4]),
+      wallTime: now - 1e4,
+      lamport: { time: 1, author: demoAuthor }
+    },
+    {
+      id: "change-2",
+      protocolVersion: 1,
+      type: "update-node",
+      payload: { nodeId: "node-1", properties: { title: "Demo Task" } },
+      hash: demoHash2,
+      parentHash: demoHash1,
+      authorDID: demoAuthor,
+      signature: new Uint8Array([5, 6, 7, 8]),
+      wallTime: now - 5e3,
+      lamport: { time: 2, author: demoAuthor }
+    }
+  ];
+}
+async function repairCommand(options) {
+  const chalk = await getChalk();
+  console.log(chalk.bold("\nxNet Data Repair\n"));
+  try {
+    let dataDir;
+    let changes = [];
+    try {
+      dataDir = findDataDir(options.dataDir);
+      changes = loadChangesFromDir(dataDir);
+    } catch {
+      console.log(chalk.yellow("Note: No data directory found."));
+      console.log(chalk.gray("Using demo data for illustration.\n"));
+      dataDir = "";
+      changes = generateDemoChanges();
+    }
+    console.log(chalk.gray("Running integrity check..."));
+    const report = await verifyIntegrity(changes);
+    if (report.issues.length === 0) {
+      console.log(chalk.green("\n\u2713 No issues found. Nothing to repair."));
+      return;
+    }
+    console.log(`
+Found ${report.issues.length} issues:`);
+    console.log(`  - ${report.summary.errors} errors`);
+    console.log(`  - ${report.summary.warnings} warnings`);
+    console.log();
+    if (options.dryRun) {
+      console.log(chalk.yellow("DRY RUN - No changes will be made\n"));
+    }
+    const { remainingIssues, repairCount } = await attemptRepair(changes, report.issues);
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            original: changes.length,
+            repaired: repairCount,
+            remaining: remainingIssues.length,
+            remainingIssues
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold("Repair results:"));
+    console.log(`  ${chalk.green("\u2713")} Repaired: ${repairCount} issues`);
+    console.log(`  ${chalk.yellow("!")} Remaining: ${remainingIssues.length} issues`);
+    if (remainingIssues.length > 0) {
+      console.log();
+      console.log(chalk.yellow("Issues that require manual intervention:"));
+      for (const issue of remainingIssues.slice(0, 5)) {
+        console.log(`  - [${issue.type}] ${issue.details}`);
+      }
+      if (remainingIssues.length > 5) {
+        console.log(chalk.gray(`  ... and ${remainingIssues.length - 5} more`));
+      }
+    }
+    if (!options.dryRun && dataDir && repairCount > 0) {
+      console.log();
+      console.log(chalk.gray("Note: Writing repaired changes requires NodeStore integration."));
+      console.log(chalk.gray("Changes are prepared but not written to disk."));
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function exportCommand(options) {
+  const chalk = await getChalk();
+  console.log(chalk.bold("\nxNet Data Export\n"));
+  try {
+    let dataDir;
+    let changes = [];
+    try {
+      dataDir = findDataDir(options.dataDir);
+      changes = loadChangesFromDir(dataDir);
+    } catch {
+      console.log(chalk.yellow("Note: No data directory found."));
+      console.log(chalk.gray("Using demo data for illustration.\n"));
+      dataDir = "";
+      changes = generateDemoChanges();
+    }
+    const outputPath = resolve(process.cwd(), options.output);
+    console.log(chalk.gray(`Source: ${dataDir || "demo data"}`));
+    console.log(chalk.gray(`Output: ${outputPath}`));
+    console.log();
+    const exportData = {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: dataDir || "demo",
+      stats: {
+        changes: changes.length,
+        roots: findRoots(changes).length,
+        heads: findHeads(changes).length,
+        depth: getChainDepth(changes)
+      },
+      changes: changes.map((c) => ({
+        ...c,
+        // Convert Uint8Array to base64 for JSON serialization
+        signature: Buffer.from(c.signature).toString("base64")
+      }))
+    };
+    const content = options.pretty ? JSON.stringify(exportData, null, 2) : JSON.stringify(exportData);
+    if (options.format === "jsonl") {
+      const lines = exportData.changes.map((c) => JSON.stringify(c)).join("\n");
+      writeFileSync(outputPath, lines, "utf-8");
+    } else {
+      writeFileSync(outputPath, content, "utf-8");
+    }
+    console.log(chalk.green(`\u2713 Exported ${changes.length} changes`));
+    console.log(chalk.gray(`  File size: ${Math.round(content.length / 1024)}KB`));
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function importCommand(options) {
+  const chalk = await getChalk();
+  console.log(chalk.bold("\nxNet Data Import\n"));
+  try {
+    const inputPath = resolve(process.cwd(), options.input);
+    if (!existsSync(inputPath)) {
+      console.error(chalk.red(`Error: Input file not found: ${inputPath}`));
+      process.exit(1);
+    }
+    console.log(chalk.gray(`Input: ${inputPath}`));
+    if (options.dryRun) {
+      console.log(chalk.yellow("\nDRY RUN - No changes will be applied\n"));
+    }
+    const content = readFileSync(inputPath, "utf-8");
+    let importData;
+    try {
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        importData = { changes: parsed };
+      } else {
+        importData = parsed;
+      }
+    } catch {
+      const lines = content.split("\n").filter((l) => l.trim());
+      importData = { changes: lines.map((l) => JSON.parse(l)) };
+    }
+    console.log(chalk.gray(`Found ${importData.changes.length} changes to import`));
+    console.log();
+    const changes = importData.changes.map((c) => ({
+      ...c,
+      signature: typeof c.signature === "string" ? new Uint8Array(Buffer.from(c.signature, "base64")) : c.signature
+    }));
+    console.log(chalk.bold("Verifying import data..."));
+    const report = await quickIntegrityCheck(changes);
+    if (report.issues.length > 0) {
+      console.log(chalk.yellow(`  \u26A0 ${report.issues.length} integrity issues found`));
+      if (report.summary.errors > 0) {
+        console.log(chalk.red(`  ${report.summary.errors} errors may prevent import`));
+      }
+    } else {
+      console.log(chalk.green("  \u2713 All changes verified"));
+    }
+    if (options.applyMigrations) {
+      console.log();
+      console.log(chalk.bold("Checking for required migrations..."));
+      console.log(chalk.gray("  (Migration detection requires schema registry)"));
+    }
+    console.log();
+    console.log(chalk.bold("Import summary:"));
+    console.log(`  Changes: ${changes.length}`);
+    console.log(`  Roots: ${findRoots(changes).length}`);
+    console.log(`  Heads: ${findHeads(changes).length}`);
+    console.log(`  Chain depth: ${getChainDepth(changes)}`);
+    if (!options.dryRun) {
+      console.log();
+      console.log(chalk.gray("Note: Writing imported changes requires NodeStore integration."));
+      console.log(chalk.gray("Changes are validated but not written to storage."));
+    }
+    console.log();
+    console.log(chalk.green("\u2713 Import validation complete"));
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Diagnose data integrity and sync issues").option("--data-dir <path>", "Path to data directory").option("-q, --quick", "Quick check (skip signature verification)").option("--json", "Output as JSON").option("-v, --verbose", "Show detailed issue information").action(async (opts) => {
+    await doctorCommand(opts);
+  });
+  program2.command("repair").description("Attempt automatic repair of data issues").option("--data-dir <path>", "Path to data directory").option("--dry-run", "Preview repairs without applying").option("--json", "Output as JSON").action(async (opts) => {
+    await repairCommand(opts);
+  });
+  program2.command("export").description("Export all data to JSON format").requiredOption("-o, --output <path>", "Output file path").option("--data-dir <path>", "Path to data directory").option("--format <type>", "Output format (json or jsonl)", "json").option("--pretty", "Pretty-print JSON output").action(async (opts) => {
+    await exportCommand(opts);
+  });
+  program2.command("import").description("Import data from JSON format").requiredOption("-i, --input <path>", "Input file path").option("--data-dir <path>", "Path to data directory").option("--dry-run", "Validate import without applying").option("--apply-migrations", "Apply schema migrations during import").action(async (opts) => {
+    await importCommand(opts);
+  });
+}
+
+// src/commands/migrate.ts
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+async function getChalk2() {
+  try {
+    const chalk = await import("chalk");
+    return chalk.default;
+  } catch {
+    const identity = (s) => s;
+    return {
+      green: identity,
+      yellow: identity,
+      red: identity,
+      blue: identity,
+      gray: identity,
+      bold: identity,
+      dim: identity
+    };
+  }
+}
+function parseSchemaIRI(iri) {
+  const match = iri.match(/([^/@]+)@(\d+\.\d+\.\d+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid schema IRI: ${iri}. Expected format: Name@version or xnet://namespace/Name@version`
+    );
+  }
+  return { name: match[1], version: match[2] };
+}
+function loadSchemasFromFile(filePath) {
+  if (!existsSync2(filePath)) {
+    throw new Error(`Schema file not found: ${filePath}`);
+  }
+  const content = readFileSync2(filePath, "utf-8");
+  const data = JSON.parse(content);
+  const schemas = /* @__PURE__ */ new Map();
+  const schemaList = Array.isArray(data) ? data : data.schemas ?? [data];
+  for (const schema of schemaList) {
+    if (schema["@id"]) {
+      schemas.set(schema["@id"], schema);
+      const name = schema.name ?? schema["@id"].split("/").pop()?.split("@")[0];
+      const version = schema.version ?? "1.0.0";
+      schemas.set(`${name}@${version}`, schema);
+    }
+  }
+  return schemas;
+}
+function findSchema(schemaIRI, schemas) {
+  if (schemas) {
+    const schema = schemas.get(schemaIRI);
+    if (schema) return schema;
+  }
+  return null;
+}
+async function analyzeCommand(options) {
+  const chalk = await getChalk2();
+  try {
+    const fromParsed = parseSchemaIRI(options.from);
+    const toParsed = parseSchemaIRI(options.to);
+    let schemas = null;
+    if (options.schemaFile) {
+      schemas = loadSchemasFromFile(options.schemaFile);
+    }
+    const fromSchema = findSchema(options.from, schemas);
+    const toSchema = findSchema(options.to, schemas);
+    if (!fromSchema || !toSchema) {
+      console.log(chalk.yellow("\nNote: Schema file not provided. Showing example output.\n"));
+      console.log(chalk.gray("Use --schema-file to load actual schemas from a JSON file.\n"));
+      const mockFromSchema = {
+        "@id": `xnet://xnet.fyi/${fromParsed.name}@${fromParsed.version}`,
+        "@type": "xnet://xnet.fyi/Schema",
+        name: fromParsed.name,
+        namespace: "xnet://xnet.fyi/",
+        version: fromParsed.version,
+        properties: [
+          { "@id": `#complete`, name: "complete", type: "checkbox", required: false },
+          { "@id": `#title`, name: "title", type: "text", required: true }
+        ]
+      };
+      const mockToSchema = {
+        "@id": `xnet://xnet.fyi/${toParsed.name}@${toParsed.version}`,
+        "@type": "xnet://xnet.fyi/Schema",
+        name: toParsed.name,
+        namespace: "xnet://xnet.fyi/",
+        version: toParsed.version,
+        properties: [
+          {
+            "@id": `#status`,
+            name: "status",
+            type: "select",
+            required: false
+          },
+          { "@id": `#title`, name: "title", type: "text", required: true },
+          { "@id": `#priority`, name: "priority", type: "text", required: true }
+        ]
+      };
+      printAnalysisResult(diffSchemas(mockFromSchema, mockToSchema), options.json, chalk);
+      return;
+    }
+    const diff = diffSchemas(fromSchema, toSchema);
+    printAnalysisResult(diff, options.json, chalk);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+function printAnalysisResult(diff, json, chalk) {
+  if (json) {
+    console.log(JSON.stringify(diff, null, 2));
+    return;
+  }
+  console.log(chalk.bold(`
+Schema changes: ${diff.fromVersion} \u2192 ${diff.toVersion}
+`));
+  if (diff.changes.length === 0) {
+    console.log(chalk.green("No changes detected."));
+    return;
+  }
+  const breaking = diff.changes.filter((c) => c.risk === "breaking");
+  const caution = diff.changes.filter((c) => c.risk === "caution");
+  const safe = diff.changes.filter((c) => c.risk === "safe");
+  if (breaking.length > 0) {
+    console.log(chalk.red(chalk.bold("BREAKING CHANGES:")));
+    for (const change of breaking) {
+      console.log(chalk.red(`  - ${change.type.toUpperCase()}: ${change.description}`));
+    }
+    console.log();
+  }
+  if (caution.length > 0) {
+    console.log(chalk.yellow(chalk.bold("CAUTION:")));
+    for (const change of caution) {
+      console.log(chalk.yellow(`  - ${change.type.toUpperCase()}: ${change.description}`));
+    }
+    console.log();
+  }
+  if (safe.length > 0) {
+    console.log(chalk.green(chalk.bold("SAFE:")));
+    for (const change of safe) {
+      console.log(chalk.green(`  - ${change.type.toUpperCase()}: ${change.description}`));
+    }
+    console.log();
+  }
+  console.log(chalk.bold("Summary:"));
+  console.log(
+    `  ${chalk.red(`${diff.summary.breaking} breaking`)} | ${chalk.yellow(`${diff.summary.caution} caution`)} | ${chalk.green(`${diff.summary.safe} safe`)}`
+  );
+  console.log();
+  if (diff.changes.some((c) => c.suggestedLens)) {
+    console.log(chalk.bold("Suggested lens:"));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log(generateLensSnippet(diff));
+    console.log(chalk.dim("\u2500".repeat(40)));
+    console.log();
+  }
+  if (diff.autoMigratable) {
+    console.log(chalk.green("\u2713 Automatic migration possible"));
+  } else {
+    console.log(chalk.yellow("\u26A0 Manual intervention required for some changes"));
+  }
+}
+async function generateCommand(options) {
+  const chalk = await getChalk2();
+  try {
+    const fromParsed = parseSchemaIRI(options.from);
+    const toParsed = parseSchemaIRI(options.to);
+    let schemas = null;
+    if (options.schemaFile) {
+      schemas = loadSchemasFromFile(options.schemaFile);
+    }
+    const fromSchema = findSchema(options.from, schemas);
+    const toSchema = findSchema(options.to, schemas);
+    const from = fromSchema ?? createMockSchema(fromParsed.name, fromParsed.version, "from");
+    const to = toSchema ?? createMockSchema(toParsed.name, toParsed.version, "to");
+    if (!fromSchema || !toSchema) {
+      console.log(chalk.yellow("\nNote: Using mock schemas for demonstration.\n"));
+    }
+    const diff = diffSchemas(from, to);
+    const sourceIRI = from["@id"];
+    const targetIRI = to["@id"];
+    const generated = generateLensCode({
+      diff,
+      sourceIRI,
+      targetIRI,
+      includeComments: true,
+      includeTodos: true
+    });
+    if (options.output) {
+      const outputPath = resolve2(process.cwd(), options.output);
+      if (existsSync2(outputPath) && !options.force) {
+        console.error(chalk.red(`Error: File already exists: ${outputPath}`));
+        console.error(chalk.gray("Use --force to overwrite."));
+        process.exit(1);
+      }
+      writeFileSync2(outputPath, generated.code, "utf-8");
+      console.log(chalk.green(`
+\u2713 Generated lens written to: ${outputPath}`));
+    } else {
+      console.log(generated.code);
+    }
+    if (!generated.isComplete) {
+      console.log(chalk.yellow("\n\u26A0 Manual completion required:"));
+      for (const item of generated.manualItems) {
+        console.log(chalk.yellow(`  - ${item}`));
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+function createMockSchema(name, version, type) {
+  if (type === "from") {
+    return {
+      "@id": `xnet://xnet.fyi/${name}@${version}`,
+      "@type": "xnet://xnet.fyi/Schema",
+      name,
+      namespace: "xnet://xnet.fyi/",
+      version,
+      properties: [
+        { "@id": `#complete`, name: "complete", type: "checkbox", required: false },
+        { "@id": `#title`, name: "title", type: "text", required: true }
+      ]
+    };
+  } else {
+    return {
+      "@id": `xnet://xnet.fyi/${name}@${version}`,
+      "@type": "xnet://xnet.fyi/Schema",
+      name,
+      namespace: "xnet://xnet.fyi/",
+      version,
+      properties: [
+        {
+          "@id": `#status`,
+          name: "status",
+          type: "select",
+          required: false
+        },
+        { "@id": `#title`, name: "title", type: "text", required: true },
+        { "@id": `#priority`, name: "priority", type: "text", required: true }
+      ]
+    };
+  }
+}
+async function runCommand(options) {
+  const chalk = await getChalk2();
+  if (!options.dryRun && !options.apply) {
+    console.error(chalk.red("Error: Must specify either --dry-run or --apply"));
+    process.exit(1);
+  }
+  if (options.dryRun && options.apply) {
+    console.error(chalk.red("Error: Cannot specify both --dry-run and --apply"));
+    process.exit(1);
+  }
+  try {
+    console.log(chalk.blue(`
+Migration: ${options.from} \u2192 ${options.to}
+`));
+    if (options.dryRun) {
+      console.log(chalk.yellow("DRY RUN - No changes will be applied\n"));
+      console.log(chalk.gray("Would migrate nodes:"));
+      console.log(chalk.gray("  - Scan data directory for nodes with schema " + options.from));
+      console.log(chalk.gray("  - Apply migration lens to each node"));
+      console.log(chalk.gray("  - Update schema version to " + options.to));
+      console.log();
+      console.log(chalk.dim("Note: Full migration requires --data-dir and --lens-file options"));
+      console.log(chalk.dim("      or a configured NodeStore with registered lenses."));
+    } else {
+      console.log(chalk.yellow("APPLY MODE - Changes will be written\n"));
+      console.log(chalk.gray("Would apply migration:"));
+      console.log(chalk.gray("  - Load nodes with schema " + options.from));
+      console.log(chalk.gray("  - Transform using migration lens"));
+      console.log(chalk.gray("  - Write updated nodes with schema " + options.to));
+      console.log();
+      console.log(chalk.dim("Note: Full migration requires --data-dir and --lens-file options"));
+      console.log(chalk.dim("      or a configured NodeStore with registered lenses."));
+    }
+    console.log();
+    console.log(chalk.green("\u2713 Migration command parsed successfully"));
+    console.log(chalk.gray("  Full implementation requires NodeStore integration."));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+function registerMigrateCommand(program2) {
+  const migrate = program2.command("migrate").description("Schema migration tools");
+  migrate.command("analyze").description("Analyze changes between two schema versions").requiredOption("--from <schema>", "Source schema (e.g., Task@1.0.0)").requiredOption("--to <schema>", "Target schema (e.g., Task@2.0.0)").option("--json", "Output as JSON").option("--schema-file <path>", "Load schemas from JSON file").action(async (opts) => {
+    await analyzeCommand(opts);
+  });
+  migrate.command("generate").description("Generate migration lens code").requiredOption("--from <schema>", "Source schema (e.g., Task@1.0.0)").requiredOption("--to <schema>", "Target schema (e.g., Task@2.0.0)").option("-o, --output <path>", "Output file path").option("--schema-file <path>", "Load schemas from JSON file").option("-f, --force", "Overwrite existing files").action(async (opts) => {
+    await generateCommand(opts);
+  });
+  migrate.command("run").description("Execute a migration").requiredOption("--from <schema>", "Source schema (e.g., Task@1.0.0)").requiredOption("--to <schema>", "Target schema (e.g., Task@2.0.0)").option("--dry-run", "Preview changes without applying").option("--apply", "Apply the migration").option("--lens-file <path>", "Path to lens file").option("--data-dir <path>", "Path to data directory").action(async (opts) => {
+    await runCommand(opts);
+  });
+}
+
+// src/commands/schema.ts
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+function extractSchemas() {
+  const schemaExportPath = process.env.XNET_SCHEMA_EXPORT || "./schemas-export.json";
+  if (existsSync3(schemaExportPath)) {
+    const content = readFileSync3(schemaExportPath, "utf-8");
+    const data = JSON.parse(content);
+    return data.schemas || data;
+  }
+  console.warn("No schemas found. Set XNET_SCHEMA_EXPORT or create schemas-export.json");
+  return [];
+}
+function formatChange(change) {
+  const icon = change.risk === "breaking" ? "!" : change.risk === "caution" ? "*" : "+";
+  return `  ${icon} ${change.description}`;
+}
+function registerSchemaCommand(program2) {
+  const schema = program2.command("schema").description("Schema extraction and diffing utilities");
+  schema.command("extract").description("Extract schemas from the codebase to a JSON file").option("-o, --output <file>", "Output file path", "schemas.json").option("--pretty", "Pretty-print the JSON output", false).action(async (options) => {
+    console.log("Extracting schemas...");
+    const schemas = extractSchemas();
+    const output = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      schemas
+    };
+    const json = options.pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+    writeFileSync3(options.output, json, "utf-8");
+    console.log(`Extracted ${schemas.length} schemas to ${options.output}`);
+  });
+  schema.command("diff").description("Compare two schema files and report changes").argument("<old-file>", "Path to the old schemas JSON file").argument("<new-file>", "Path to the new schemas JSON file").option("-o, --output <file>", "Output diff to JSON file").option("--fail-on-breaking", "Exit with code 1 if breaking changes found", false).option("--quiet", "Only output JSON, no console messages", false).action(
+    async (oldFile, newFile, options) => {
+      if (!existsSync3(oldFile)) {
+        console.error(`Error: Old file not found: ${oldFile}`);
+        process.exit(1);
+      }
+      if (!existsSync3(newFile)) {
+        console.error(`Error: New file not found: ${newFile}`);
+        process.exit(1);
+      }
+      const oldData = JSON.parse(readFileSync3(oldFile, "utf-8"));
+      const newData = JSON.parse(readFileSync3(newFile, "utf-8"));
+      const oldSchemas = new Map(oldData.schemas.map((s) => [s["@id"], s]));
+      const newSchemas = new Map(newData.schemas.map((s) => [s["@id"], s]));
+      const diffs = [];
+      let totalChanges = 0;
+      let breakingChanges = 0;
+      let cautionChanges = 0;
+      let safeChanges = 0;
+      for (const [iri, oldSchema] of oldSchemas) {
+        const newSchema = newSchemas.get(iri);
+        if (newSchema) {
+          const result = diffSchemas(oldSchema, newSchema);
+          if (result.changes.length > 0) {
+            diffs.push({ schemaName: oldSchema.name, result });
+            totalChanges += result.changes.length;
+            breakingChanges += result.summary.breaking;
+            cautionChanges += result.summary.caution;
+            safeChanges += result.summary.safe;
+          }
+        } else {
+          diffs.push({
+            schemaName: oldSchema.name,
+            result: {
+              fromVersion: oldSchema.version,
+              toVersion: "removed",
+              changes: [
+                {
+                  type: "remove",
+                  property: oldSchema["@id"],
+                  risk: "breaking",
+                  description: `Schema "${oldSchema.name}" was removed`
+                }
+              ],
+              overallRisk: "breaking",
+              autoMigratable: false,
+              summary: { safe: 0, caution: 0, breaking: 1 }
+            }
+          });
+          totalChanges += 1;
+          breakingChanges += 1;
+        }
+      }
+      for (const [iri, newSchema] of newSchemas) {
+        if (!oldSchemas.has(iri)) {
+          diffs.push({
+            schemaName: newSchema.name,
+            result: {
+              fromVersion: "new",
+              toVersion: newSchema.version,
+              changes: [
+                {
+                  type: "add",
+                  property: newSchema["@id"],
+                  risk: "safe",
+                  description: `New schema "${newSchema.name}" added`
+                }
+              ],
+              overallRisk: "safe",
+              autoMigratable: true,
+              summary: { safe: 1, caution: 0, breaking: 0 }
+            }
+          });
+          totalChanges += 1;
+          safeChanges += 1;
+        }
+      }
+      const output = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        diffs,
+        summary: {
+          schemasChanged: diffs.length,
+          totalChanges,
+          breakingChanges,
+          cautionChanges,
+          safeChanges
+        }
+      };
+      if (options.output) {
+        writeFileSync3(options.output, JSON.stringify(output, null, 2), "utf-8");
+      }
+      if (!options.quiet) {
+        if (diffs.length === 0) {
+          console.log("No schema changes detected.");
+        } else {
+          console.log(`
+Schema changes detected: ${diffs.length} schema(s) changed
+`);
+          for (const { schemaName, result } of diffs) {
+            const riskIcon = result.overallRisk === "breaking" ? "!" : result.overallRisk === "caution" ? "*" : "+";
+            console.log(
+              `${riskIcon} ${schemaName} (${result.fromVersion} -> ${result.toVersion})`
+            );
+            for (const change of result.changes) {
+              console.log(formatChange(change));
+            }
+            console.log();
+          }
+          console.log("Summary:");
+          console.log(`  Breaking: ${breakingChanges}`);
+          console.log(`  Caution:  ${cautionChanges}`);
+          console.log(`  Safe:     ${safeChanges}`);
+        }
+      }
+      if (options.failOnBreaking && breakingChanges > 0) {
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/cli.ts
+program.name("xnet").description("xNet CLI - Schema migrations, diagnostics, and development tools").version("0.0.1");
+registerMigrateCommand(program);
+registerSchemaCommand(program);
+registerDoctorCommand(program);
+program.parse();