@neuroverseos/governance 0.2.2 → 0.3.0

package/dist/infer-world-7GVZWFX4.js

@@ -0,0 +1,543 @@
+import "./chunk-YZFATT7X.js";
+
+// src/cli/infer-world.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { writeFile } from "fs/promises";
+import { join, basename, resolve } from "path";
+var SCAN_PATTERNS = {
+  "program.md": { signal: "experiment goals / agent instructions", confidence: 0.9 },
+  "train.py": { signal: "model training code", confidence: 0.8 },
+  "train.js": { signal: "model training code", confidence: 0.8 },
+  "train.ts": { signal: "model training code", confidence: 0.8 },
+  "prepare.py": { signal: "data preparation", confidence: 0.7 },
+  "dataset.yaml": { signal: "dataset configuration", confidence: 0.8 },
+  "dataset.json": { signal: "dataset configuration", confidence: 0.8 },
+  "config.yaml": { signal: "project configuration", confidence: 0.5 },
+  "config.json": { signal: "project configuration", confidence: 0.5 },
+  "pyproject.toml": { signal: "Python project", confidence: 0.4 },
+  "requirements.txt": { signal: "Python dependencies", confidence: 0.5 },
+  "setup.py": { signal: "Python package", confidence: 0.4 },
+  "Makefile": { signal: "build automation", confidence: 0.3 },
+  "docker-compose.yml": { signal: "containerized environment", confidence: 0.4 },
+  "Dockerfile": { signal: "containerized environment", confidence: 0.4 }
+};
+var RESEARCH_DIRECTORIES = ["experiments", "results", "notebooks", "models", "checkpoints", "logs", "data", "eval"];
+function scanRepo(repoPath) {
+  const signals = [];
+  let entries;
+  try {
+    entries = readdirSync(repoPath);
+  } catch {
+    return signals;
+  }
+  for (const entry of entries) {
+    const lower = entry.toLowerCase();
+    const fullPath = join(repoPath, entry);
+    if (SCAN_PATTERNS[lower]) {
+      signals.push({
+        path: entry,
+        signal: SCAN_PATTERNS[lower].signal,
+        confidence: SCAN_PATTERNS[lower].confidence
+      });
+    }
+    if (entry !== lower && SCAN_PATTERNS[entry]) {
+      signals.push({
+        path: entry,
+        signal: SCAN_PATTERNS[entry].signal,
+        confidence: SCAN_PATTERNS[entry].confidence
+      });
+    }
+    if (lower === "readme.md" || lower === "readme.rst" || lower === "readme.txt") {
+      signals.push({ path: entry, signal: "documentation", confidence: 0.3 });
+    }
+    if (lower === "package.json" || lower === "cargo.toml" || lower === "go.mod") {
+      signals.push({ path: entry, signal: "project manifest", confidence: 0.4 });
+    }
+    try {
+      if (statSync(fullPath).isDirectory() && RESEARCH_DIRECTORIES.includes(lower)) {
+        signals.push({
+          path: entry + "/",
+          signal: `${lower} directory`,
+          confidence: 0.6
+        });
+      }
+    } catch {
+    }
+  }
+  return signals;
+}
+var DATASET_PATTERNS = [
+  /dataset\s*[:=]\s*["']?([A-Za-z0-9_\-]+)/i,
+  /--dataset\s+["']?([A-Za-z0-9_\-]+)/i,
+  /load_dataset\(["']([^"']+)/i,
+  /TinyStories/i,
+  /OpenWebText/i,
+  /WikiText/i,
+  /C4/i,
+  /The\s*Pile/i,
+  /MNIST/i,
+  /CIFAR/i,
+  /ImageNet/i
+];
+var METRIC_PATTERNS = [
+  /val_bpb/i,
+  /val_loss/i,
+  /val_acc(?:uracy)?/i,
+  /test_acc(?:uracy)?/i,
+  /perplexity/i,
+  /bleu/i,
+  /rouge/i,
+  /f1[_\s]?score/i,
+  /auc/i,
+  /mse/i,
+  /rmse/i,
+  /mae/i
+];
+var ARCHITECTURE_PATTERNS = [
+  /transformer/i,
+  /RWKV/i,
+  /SSM/i,
+  /Mamba/i,
+  /linear\s*attention/i,
+  /GPT/i,
+  /BERT/i,
+  /ResNet/i,
+  /CNN/i,
+  /RNN/i,
+  /LSTM/i,
+  /GRU/i,
+  /ViT/i,
+  /diffusion/i,
+  /autoencoder/i,
+  /GAN/i
+];
+var FRAMEWORK_PATTERNS = [
+  [/import\s+torch|from\s+torch/i, "PyTorch"],
+  [/import\s+tensorflow|from\s+tensorflow/i, "TensorFlow"],
+  [/import\s+jax|from\s+jax/i, "JAX"],
+  [/from\s+transformers\s+import/i, "HuggingFace Transformers"],
+  [/import\s+keras|from\s+keras/i, "Keras"],
+  [/torch/i, "PyTorch"]
+];
+function readFileContent(path, maxBytes = 5e4) {
+  try {
+    const stat = statSync(path);
+    if (stat.size > maxBytes) {
+      return readFileSync(path, { encoding: "utf-8", flag: "r" }).slice(0, maxBytes);
+    }
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function extractFromContent(repoPath, signals) {
+  const result = {
+    architectures: [],
+    constraints: [],
+    goals: []
+  };
+  const filesToRead = [
+    "program.md",
+    "train.py",
+    "train.js",
+    "train.ts",
+    "prepare.py",
+    "config.yaml",
+    "config.json",
+    "dataset.yaml",
+    "dataset.json",
+    "README.md",
+    "readme.md"
+  ];
+  const allContent = [];
+  for (const file of filesToRead) {
+    const content = readFileContent(join(repoPath, file));
+    if (content) {
+      allContent.push(content);
+    }
+  }
+  const combined = allContent.join("\n");
+  if (!combined) return result;
+  for (const pattern of DATASET_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      result.dataset = match[1] || match[0].trim();
+      break;
+    }
+  }
+  for (const pattern of METRIC_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      result.metric = match[0].trim().toLowerCase().replace(/\s+/g, "_");
+      break;
+    }
+  }
+  if (result.metric) {
+    const lossLike = /loss|bpb|perplexity|mse|rmse|mae|error/i.test(result.metric);
+    result.optimization = lossLike ? "minimize" : "maximize";
+  }
+  const archs = /* @__PURE__ */ new Set();
+  for (const pattern of ARCHITECTURE_PATTERNS) {
+    const match = combined.match(pattern);
+    if (match) {
+      archs.add(match[0].trim());
+    }
+  }
+  result.architectures = [...archs];
+  for (const [pattern, framework] of FRAMEWORK_PATTERNS) {
+    if (pattern.test(combined)) {
+      result.framework = framework;
+      break;
+    }
+  }
+  const programContent = readFileContent(join(repoPath, "program.md"));
+  if (programContent) {
+    result.hasProgram = true;
+    const lines = programContent.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if ((trimmed.startsWith("- ") || trimmed.startsWith("* ")) && trimmed.length > 10 && trimmed.length < 200) {
+        result.goals.push(trimmed.slice(2).trim());
+      }
+    }
+  }
+  result.hasExperimentLoop = /experiment|loop|iteration|epoch|trial|run|sweep/i.test(combined) && /result|metric|eval|score|loss|accuracy/i.test(combined);
+  return result;
+}
+function classifyEnvironment(signals, extracted) {
+  let type = "unknown";
+  let confidence = 0;
+  const hasTrainCode = signals.some((s) => s.signal.includes("training code"));
+  const hasDataset = !!extracted.dataset;
+  const hasMetric = !!extracted.metric;
+  const hasExperimentLoop = !!extracted.hasExperimentLoop;
+  const hasResearchDirs = signals.some(
+    (s) => ["experiments directory", "results directory", "notebooks directory", "models directory"].includes(s.signal)
+  );
+  const researchScore = (hasTrainCode ? 30 : 0) + (hasDataset ? 20 : 0) + (hasMetric ? 20 : 0) + (hasExperimentLoop ? 15 : 0) + (hasResearchDirs ? 10 : 0) + (extracted.hasProgram ? 15 : 0);
+  if (researchScore >= 40) {
+    type = "research";
+    confidence = Math.min(researchScore, 100);
+  } else if (signals.length > 0) {
+    type = "application";
+    confidence = 30;
+  }
+  return {
+    type,
+    confidence,
+    dataset: extracted.dataset || null,
+    metric: extracted.metric || null,
+    optimization: extracted.optimization || null,
+    framework: extracted.framework || null,
+    architectures: extracted.architectures || [],
+    constraints: extracted.constraints || [],
+    hasExperimentLoop,
+    hasProgram: !!extracted.hasProgram,
+    goals: extracted.goals || [],
+    files: signals
+  };
+}
+function generateWorldFromDetection(env, repoName) {
+  const worldId = repoName.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  const dataset = env.dataset || "UNDETECTED";
+  const metric = env.metric || "val_loss";
+  const optimization = env.optimization || "minimize";
+  const framework = env.framework || "Unknown";
+  const architectures = env.architectures.length > 0 ? env.architectures.join(", ") : "not detected";
+  const contextDescription = env.type === "research" ? `ML research using ${framework} on ${dataset}` : `AI application with governance requirements`;
+  const goals = env.goals.length > 0 ? env.goals.slice(0, 3).map((g) => `  - ${g}`).join("\n") : "  - Define research goals here";
+  return `---
+world_id: ${worldId}
+name: ${repoName} Research World
+version: 1.0.0
+runtime_mode: SIMULATION
+default_profile: inferred
+alternative_profile: strict
+---
+
+# Thesis
+
+${contextDescription}. Experiments must be reproducible, metrics must be tracked, and agents must operate within the declared research context. This world was inferred from repository structure \u2014 review and refine the constraints below.
+
+# Invariants
+
+- \`experiments_must_be_reproducible\` \u2014 Every experiment must log architecture, hyperparameters, dataset, and training config sufficient to reproduce results (structural, immutable)
+- \`metrics_must_be_recorded\` \u2014 Every training run must produce the primary evaluation metric (${metric}); runs without metrics are invalid (structural, immutable)
+- \`dataset_is_${dataset.toLowerCase().replace(/[^a-z0-9]+/g, "_")}\` \u2014 The dataset "${dataset}" must be used for training and evaluation (structural, immutable)
+- \`compute_budget_enforced\` \u2014 Experiments must respect declared compute limits (structural, immutable)
+
+# State
+
+## experiments_run
+- type: number
+- min: 0
+- max: 10000
+- step: 1
+- default: 0
+- label: Experiments Run
+- description: Total number of experiments completed
+
+## best_metric_value
+- type: number
+- min: -1000
+- max: 1000
+- step: 0.01
+- default: ${optimization === "minimize" ? "100" : "-1000"}
+- label: Best ${metric}
+- description: Best value achieved for ${metric}
+
+## keep_rate
+- type: number
+- min: 0
+- max: 100
+- step: 1
+- default: 0
+- label: Keep Rate
+- description: Percentage of experiments that improved on the best result
+
+## compute_used_minutes
+- type: number
+- min: 0
+- max: 100000
+- step: 1
+- default: 0
+- label: Compute Used (minutes)
+- description: Total wall-clock training time consumed
+
+## compute_budget_minutes
+- type: number
+- min: 0
+- max: 100000
+- step: 60
+- default: 1440
+- label: Compute Budget (minutes)
+- description: Maximum allowed compute time
+
+## failed_experiments
+- type: number
+- min: 0
+- max: 10000
+- step: 1
+- default: 0
+- label: Failed Experiments
+- description: Number of experiments that failed to produce valid results
+
+# Assumptions
+
+## inferred
+- name: Inferred Configuration
+- description: Configuration inferred from repository structure. Framework: ${framework}. Architectures: ${architectures}.
+- framework: ${framework.toLowerCase().replace(/\s+/g, "_")}
+- dataset: ${dataset.toLowerCase()}
+- metric: ${metric}
+
+## strict
+- name: Strict Configuration
+- description: Conservative settings with tight compute limits and strict reproducibility requirements.
+- framework: ${framework.toLowerCase().replace(/\s+/g, "_")}
+- dataset: ${dataset.toLowerCase()}
+- metric: ${metric}
+
+# Rules
+
+## rule-001: Compute Budget Exhausted (structural)
+When compute budget is exceeded, the research loop must halt.
+
+When compute_used_minutes > compute_budget_minutes [state]
+Then research_viability *= 0.00
+Collapse: research_viability < 0.05
+
+> trigger: Compute usage exceeds declared budget.
+> rule: Compute budget is a hard constraint. Exceeding it halts all experiments.
+> shift: Research loop terminates. Final results are reported.
+> effect: Research viability set to zero.
+
+## rule-002: High Failure Rate (degradation)
+Too many failed experiments indicate a systemic problem.
+
+When failed_experiments > 5 [state] AND experiments_run > 0 [state]
+Then research_viability *= 0.50
+
+> trigger: More than 5 experiments have failed.
+> rule: High failure rates waste compute and signal infrastructure problems.
+> shift: Research viability degrades. Investigation needed.
+> effect: Research viability reduced to 50%.
+
+## rule-003: No Metrics Recorded (structural)
+Experiments without metrics are invalid.
+
+When experiments_run > 0 [state] AND best_metric_value == ${optimization === "minimize" ? "100" : "-1000"} [state]
+Then research_viability *= 0.30
+Collapse: research_viability < 0.05
+
+> trigger: Experiments ran but no metric improvement from default.
+> rule: Research without measurement is not research.
+> shift: Research viability drops sharply.
+> effect: Research viability reduced to 30%.
+
+## rule-004: Strong Progress (advantage)
+Consistent metric improvement validates the research approach.
+
+When keep_rate > 20 [state] AND experiments_run > 5 [state]
+Then research_viability *= 1.20
+
+> trigger: Keep rate above 20% after 5+ experiments.
+> rule: Productive research should be encouraged.
+> shift: Research viability improves.
+> effect: Research viability boosted by 20%.
+
+# Gates
+
+- BREAKTHROUGH: research_viability >= 90
+- PRODUCTIVE: research_viability >= 60
+- ONGOING: research_viability >= 35
+- STRUGGLING: research_viability > 10
+- HALTED: research_viability <= 10
+
+# Outcomes
+
+## research_viability
+- type: number
+- range: 0-100
+- display: percentage
+- label: Research Viability
+- primary: true
+
+## best_metric_value
+- type: number
+- range: -1000-1000
+- display: decimal
+- label: Best ${metric}
+
+## keep_rate
+- type: number
+- range: 0-100
+- display: percentage
+- label: Keep Rate
+`;
+}
+function parseArgs(argv) {
+  let repoPath = "";
+  let outputPath = "";
+  let json = false;
+  let dryRun = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--output" && i + 1 < argv.length) {
+      outputPath = argv[++i];
+    } else if (arg === "--json") {
+      json = true;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (!arg.startsWith("-") && !repoPath) {
+      repoPath = arg;
+    }
+  }
+  return { repoPath, outputPath, json, dryRun };
+}
+async function main(argv = process.argv.slice(2)) {
+  try {
+    const args = parseArgs(argv);
+    if (!args.repoPath) {
+      process.stderr.write("Usage: neuroverse infer-world <repo-path> [options]\n\n");
+      process.stderr.write("Scans an existing repository and generates a governance world file.\n\n");
+      process.stderr.write("Options:\n");
+      process.stderr.write("  --output <path>   Output file path\n");
+      process.stderr.write("  --json            Output detection results as JSON\n");
+      process.stderr.write("  --dry-run         Show detections without writing\n");
+      process.stderr.write("\nExample:\n");
+      process.stderr.write("  neuroverse infer-world ./my-research-repo\n");
+      process.exit(1);
+      return;
+    }
+    const repoPath = resolve(args.repoPath);
+    if (!existsSync(repoPath)) {
+      process.stderr.write(`Repository not found: ${repoPath}
+`);
+      process.exit(1);
+      return;
+    }
+    process.stderr.write(`Scanning ${repoPath}...
+`);
+    const signals = scanRepo(repoPath);
+    if (signals.length === 0) {
+      process.stderr.write("No recognizable project structure detected.\n");
+      process.exit(2);
+      return;
+    }
+    const extracted = extractFromContent(repoPath, signals);
+    const env = classifyEnvironment(signals, extracted);
+    if (args.json) {
+      process.stdout.write(JSON.stringify(env, null, 2) + "\n");
+      process.exit(0);
+      return;
+    }
+    process.stderr.write("\n");
+    process.stderr.write(`Detected: ${env.type} environment (${env.confidence}% confidence)
+`);
+    if (env.dataset) process.stderr.write(`  Dataset:       ${env.dataset}
+`);
+    if (env.metric) process.stderr.write(`  Metric:        ${env.metric} (${env.optimization})
+`);
+    if (env.framework) process.stderr.write(`  Framework:     ${env.framework}
+`);
+    if (env.architectures.length > 0) process.stderr.write(`  Architectures: ${env.architectures.join(", ")}
+`);
+    if (env.hasExperimentLoop) process.stderr.write(`  Experiment loop detected
+`);
+    if (env.hasProgram) process.stderr.write(`  Program file found (agent instructions)
+`);
+    process.stderr.write("\n");
+    process.stderr.write("  Files analyzed:\n");
+    for (const s of env.files) {
+      process.stderr.write(`    ${s.path} \u2014 ${s.signal}
+`);
+    }
+    process.stderr.write("\n");
+    if (args.dryRun) {
+      process.stderr.write("Dry run \u2014 no files written.\n");
+      process.exit(0);
+      return;
+    }
+    const repoName = basename(repoPath);
+    const worldContent = generateWorldFromDetection(env, repoName);
+    const outputPath = args.outputPath || join(repoPath, "inferred.nv-world.md");
+    if (existsSync(outputPath)) {
+      process.stderr.write(`File already exists: ${outputPath}
+`);
+      process.stderr.write("Use --output to specify a different path.\n");
+      process.exit(1);
+      return;
+    }
+    await writeFile(outputPath, worldContent, "utf-8");
+    process.stderr.write(`\u2713 World created: ${outputPath}
+
+`);
+    process.stderr.write("Next steps:\n");
+    process.stderr.write(`  Review and refine   Edit ${outputPath}
+`);
+    process.stderr.write(`  Compile             neuroverse bootstrap --input ${outputPath} --output ./world/ --validate
+`);
+    process.stderr.write(`  Simulate            neuroverse simulate ${outputPath} --steps 5
+`);
+    process.stderr.write("\n");
+    const result = {
+      created: outputPath,
+      environment: env,
+      nextSteps: [
+        `Edit ${outputPath} to refine inferred governance rules`,
+        `neuroverse bootstrap --input ${outputPath} --output ./world/ --validate`,
+        `neuroverse simulate ${outputPath} --steps 5`
+      ]
+    };
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write(`infer-world failed: ${e instanceof Error ? e.message : e}
+`);
+    process.exit(3);
+  }
+}
+export {
+  main
+};