@runcontext/cli 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,16 +1,15 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command11 } from "commander";
 
-// src/commands/build.ts
+// src/commands/lint.ts
 import { Command } from "commander";
+import chalk2 from "chalk";
 import path from "path";
-import fs from "fs";
 import {
-  loadConfig,
   compile,
-  emitManifest,
+  loadConfig,
   LintEngine,
   ALL_RULES
 } from "@runcontext/core";
@@ -22,502 +21,659 @@ function formatDiagnostics(diagnostics) {
     return chalk.green("No issues found.");
   }
   const lines = [];
-  let errorCount = 0;
-  let warningCount = 0;
   for (const d of diagnostics) {
-    const location = `${d.source.file}:${d.source.line}:${d.source.col}`;
-    const severityLabel = d.severity === "error" ? chalk.red("error") : chalk.yellow("warning");
-    if (d.severity === "error") {
-      errorCount++;
-    } else {
-      warningCount++;
-    }
-    lines.push(`  ${location}  ${severityLabel}  ${chalk.dim(d.ruleId)}  ${d.message}`);
+    const icon = d.severity === "error" ? chalk.red("error") : chalk.yellow("warning");
+    const loc = chalk.gray(
+      `${d.location.file}:${d.location.line}:${d.location.column}`
+    );
+    const rule = chalk.gray(`[${d.ruleId}]`);
+    const fixTag = d.fixable ? chalk.blue(" (fixable)") : "";
+    lines.push(`  ${icon} ${d.message} ${rule}${fixTag}`);
+    lines.push(`    ${loc}`);
   }
+  const errorCount = diagnostics.filter((d) => d.severity === "error").length;
+  const warnCount = diagnostics.filter((d) => d.severity === "warning").length;
   lines.push("");
   const parts = [];
-  if (errorCount > 0) {
-    parts.push(chalk.red(`${errorCount} error${errorCount !== 1 ? "s" : ""}`));
-  }
-  if (warningCount > 0) {
-    parts.push(chalk.yellow(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`));
-  }
+  if (errorCount > 0) parts.push(chalk.red(`${errorCount} error(s)`));
+  if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warning(s)`));
   lines.push(parts.join(", "));
   return lines.join("\n");
 }
+function formatTierScore(score) {
+  const lines = [];
+  const tierColor = getTierColor(score.tier);
+  lines.push(
+    `${chalk.bold(score.model)}: ${tierColor(score.tier.toUpperCase())}`
+  );
+  lines.push("");
+  lines.push(formatTierSection("Bronze", score.bronze.passed, score.bronze.checks));
+  lines.push(formatTierSection("Silver", score.silver.passed, score.silver.checks));
+  lines.push(formatTierSection("Gold", score.gold.passed, score.gold.checks));
+  return lines.join("\n");
+}
+function formatTierSection(label, passed, checks) {
+  const lines = [];
+  const status = passed ? chalk.green("PASS") : chalk.red("FAIL");
+  lines.push(`  ${label}: ${status}`);
+  for (const check of checks) {
+    const icon = check.passed ? chalk.green("  +") : chalk.red("  -");
+    lines.push(`  ${icon} ${check.label}`);
+    if (check.detail && !check.passed) {
+      lines.push(chalk.gray(`      ${check.detail}`));
+    }
+  }
+  return lines.join("\n");
+}
+function getTierColor(tier) {
+  switch (tier) {
+    case "gold":
+      return chalk.yellow;
+    case "silver":
+      return chalk.white;
+    case "bronze":
+      return chalk.hex("#CD7F32");
+    default:
+      return chalk.gray;
+  }
+}
+function formatError(message) {
+  return chalk.red(`Error: ${message}`);
+}
+function formatSuccess(message) {
+  return chalk.green(message);
+}
 
 // src/formatters/json.ts
-function formatDiagnosticsJson(diagnostics) {
-  return JSON.stringify(diagnostics, null, 2);
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
 }
 
-// src/commands/build.ts
-var buildCommand = new Command("build").description("Compile context files and emit manifest").option("--format <format>", "output format for diagnostics (pretty|json)", "pretty").action(async (opts) => {
+// src/commands/lint.ts
+var lintCommand = new Command("lint").description("Run all lint rules against context files").option("--context-dir <path>", "Path to context directory").option("--format <type>", "Output format: pretty or json", "pretty").action(async (opts) => {
   try {
-    const config = await loadConfig(process.cwd());
-    const rootDir = config.paths?.rootDir || process.cwd();
-    const contextDir = path.resolve(rootDir, config.paths?.contextDir || "context");
-    const distDir = path.resolve(rootDir, config.paths?.distDir || "dist");
-    const { graph, diagnostics: compileDiags } = await compile({ contextDir, config });
-    const engine = new LintEngine(config.lint?.rules);
+    const config = loadConfig(process.cwd());
+    const contextDir = opts.contextDir ? path.resolve(opts.contextDir) : path.resolve(config.context_dir);
+    const { graph, diagnostics: compileDiags } = await compile({
+      contextDir,
+      config
+    });
+    const overrides = config.lint?.severity_overrides;
+    const engine = new LintEngine(overrides);
     for (const rule of ALL_RULES) {
       engine.register(rule);
     }
     const lintDiags = engine.run(graph);
     const allDiags = [...compileDiags, ...lintDiags];
-    if (allDiags.length > 0) {
-      const output = opts.format === "json" ? formatDiagnosticsJson(allDiags) : formatDiagnostics(allDiags);
-      console.error(output);
+    if (config.minimum_tier) {
+      const tierOrder = ["none", "bronze", "silver", "gold"];
+      const minIdx = tierOrder.indexOf(config.minimum_tier);
+      for (const [modelName, score] of graph.tiers) {
+        const actualIdx = tierOrder.indexOf(score.tier);
+        if (actualIdx < minIdx) {
+          allDiags.push({
+            ruleId: "tier/minimum-tier",
+            severity: "error",
+            message: `Model "${modelName}" is tier "${score.tier}" but minimum_tier is "${config.minimum_tier}"`,
+            location: { file: `model:${modelName}`, line: 1, column: 1 },
+            fixable: false
+          });
+        }
+      }
+    }
+    if (opts.format === "json") {
+      console.log(formatJson(allDiags));
+    } else {
+      console.log(formatDiagnostics(allDiags));
     }
-    const manifest = emitManifest(graph, config);
-    fs.mkdirSync(distDir, { recursive: true });
-    const manifestPath = path.join(distDir, "context.manifest.json");
-    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
-    const summary = [
-      `Built manifest: ${manifest.concepts.length} concepts`,
-      `${manifest.products.length} products`,
-      `${manifest.policies.length} policies`,
-      `${manifest.entities.length} entities`,
-      `${manifest.terms.length} terms`,
-      `${manifest.owners.length} owners`
-    ].join(", ");
-    console.log(summary);
-    console.log(`Manifest written to ${manifestPath}`);
     const hasErrors = allDiags.some((d) => d.severity === "error");
     if (hasErrors) {
       process.exit(1);
     }
   } catch (err) {
-    console.error("Build failed:", err.message);
+    console.error(chalk2.red(`Lint failed: ${err.message}`));
     process.exit(1);
   }
 });
 
-// src/commands/lint.ts
+// src/commands/build.ts
 import { Command as Command2 } from "commander";
+import chalk3 from "chalk";
 import path2 from "path";
-import {
-  loadConfig as loadConfig2,
-  compile as compile2,
-  LintEngine as LintEngine2,
-  ALL_RULES as ALL_RULES2
-} from "@runcontext/core";
-var lintCommand = new Command2("lint").description("Lint context files and report diagnostics").option("--format <format>", "output format (pretty|json)", "pretty").option("--fix", "apply autofixes (placeholder)").action(async (opts) => {
-  if (opts.fix) {
-    console.log("Use 'context fix' for autofixes.");
-    return;
-  }
+import fs from "fs";
+import { compile as compile2, loadConfig as loadConfig2, emitManifest } from "@runcontext/core";
+var buildCommand = new Command2("build").description("Compile context files and emit manifest JSON").option("--context-dir <path>", "Path to context directory").option("--output-dir <path>", "Path to output directory").option("--format <type>", "Output format: pretty or json", "pretty").action(async (opts) => {
   try {
-    const config = await loadConfig2(process.cwd());
-    const rootDir = config.paths?.rootDir || process.cwd();
-    const contextDir = path2.resolve(rootDir, config.paths?.contextDir || "context");
-    const { graph, diagnostics: compileDiags } = await compile2({ contextDir, config });
-    const engine = new LintEngine2(config.lint?.rules);
-    for (const rule of ALL_RULES2) {
-      engine.register(rule);
-    }
-    const lintDiags = engine.run(graph);
-    const allDiags = [...compileDiags, ...lintDiags];
-    const output = opts.format === "json" ? formatDiagnosticsJson(allDiags) : formatDiagnostics(allDiags);
-    console.log(output);
-    const hasErrors = allDiags.some((d) => d.severity === "error");
-    if (hasErrors) {
+    const config = loadConfig2(process.cwd());
+    const contextDir = opts.contextDir ? path2.resolve(opts.contextDir) : path2.resolve(config.context_dir);
+    const outputDir = opts.outputDir ? path2.resolve(opts.outputDir) : path2.resolve(config.output_dir);
+    const { graph, diagnostics } = await compile2({ contextDir, config });
+    const errors = diagnostics.filter((d) => d.severity === "error");
+    if (errors.length > 0) {
+      if (opts.format === "json") {
+        console.log(formatJson({ success: false, errors }));
+      } else {
+        console.error(
+          chalk3.red(`Build failed with ${errors.length} error(s):`)
+        );
+        for (const e of errors) {
+          console.error(chalk3.red(`  - ${e.message} [${e.ruleId}]`));
+        }
+      }
       process.exit(1);
     }
+    const manifest = emitManifest(graph, config);
+    fs.mkdirSync(outputDir, { recursive: true });
+    const outputPath = path2.join(outputDir, "contextkit-manifest.json");
+    fs.writeFileSync(outputPath, JSON.stringify(manifest, null, 2), "utf-8");
+    if (opts.format === "json") {
+      console.log(formatJson({ success: true, outputPath, manifest }));
+    } else {
+      console.log(formatSuccess(`Manifest written to ${outputPath}`));
+    }
   } catch (err) {
-    console.error("Lint failed:", err.message);
+    console.error(formatError(err.message));
     process.exit(1);
   }
 });
 
-// src/commands/init.ts
+// src/commands/tier.ts
 import { Command as Command3 } from "commander";
-import fs2 from "fs";
+import chalk4 from "chalk";
 import path3 from "path";
-var SAMPLE_CONCEPT = `kind: concept
-id: example-concept
-definition: An example concept to get you started.
-owner: example-team
-tags:
-  - example
-status: draft
-`;
-var SAMPLE_OWNER = `kind: owner
-id: example-team
-displayName: Example Team
-email: team@example.com
-`;
-function generateConfig(projectName) {
-  return `project:
-  id: ${projectName}
-  displayName: "${projectName}"
-  version: "0.1.0"
-
-paths:
-  contextDir: context
-  distDir: dist
-
-lint:
-  defaultSeverity: warning
-`;
-}
-var initCommand = new Command3("init").description("Create a new ContextKit project").option("--name <name>", "project name (defaults to directory basename)").action((opts) => {
-  const cwd = process.cwd();
-  const projectName = opts.name || path3.basename(cwd);
-  const dirs = [
-    "context/concepts",
-    "context/products",
-    "context/policies",
-    "context/entities",
-    "context/owners",
-    "context/terms"
-  ];
-  const files = [
-    { path: "context/concepts/example-concept.ctx.yaml", content: SAMPLE_CONCEPT },
-    { path: "context/owners/example-team.owner.yaml", content: SAMPLE_OWNER },
-    { path: "contextkit.config.yaml", content: generateConfig(projectName) }
-  ];
-  const created = [];
-  for (const dir of dirs) {
-    const fullPath = path3.join(cwd, dir);
-    fs2.mkdirSync(fullPath, { recursive: true });
-    created.push(dir + "/");
-  }
-  for (const file of files) {
-    const fullPath = path3.join(cwd, file.path);
-    if (!fs2.existsSync(fullPath)) {
-      fs2.writeFileSync(fullPath, file.content, "utf-8");
-      created.push(file.path);
+import { compile as compile3, loadConfig as loadConfig3, computeTier } from "@runcontext/core";
+var tierCommand = new Command3("tier").description("Show tier scorecard for one or all models").argument("[model-name]", "Specific model name to check").option("--context-dir <path>", "Path to context directory").option("--format <type>", "Output format: pretty or json", "pretty").action(async (modelName, opts) => {
+  try {
+    const config = loadConfig3(process.cwd());
+    const contextDir = opts.contextDir ? path3.resolve(opts.contextDir) : path3.resolve(config.context_dir);
+    const { graph } = await compile3({ contextDir, config });
+    let scores;
+    if (modelName) {
+      if (!graph.models.has(modelName)) {
+        console.error(formatError(`Model '${modelName}' not found.`));
+        const available = [...graph.models.keys()].join(", ");
+        if (available) {
+          console.error(chalk4.gray(`Available models: ${available}`));
+        }
+        process.exit(1);
+      }
+      scores = [computeTier(modelName, graph)];
     } else {
-      console.log(`  Skipped (already exists): ${file.path}`);
+      scores = [...graph.models.keys()].map(
+        (name) => computeTier(name, graph)
+      );
     }
-  }
-  console.log(`Initialized ContextKit project "${projectName}":`);
-  for (const item of created) {
-    console.log(`  created ${item}`);
+    if (scores.length === 0) {
+      console.log(
+        opts.format === "json" ? formatJson([]) : chalk4.yellow("No models found.")
+      );
+      return;
+    }
+    if (opts.format === "json") {
+      console.log(formatJson(scores));
+    } else {
+      for (const score of scores) {
+        console.log(formatTierScore(score));
+        console.log("");
+      }
+    }
+  } catch (err) {
+    console.error(formatError(err.message));
+    process.exit(1);
   }
 });
 
 // src/commands/explain.ts
 import { Command as Command4 } from "commander";
-import fs3 from "fs";
+import chalk5 from "chalk";
 import path4 from "path";
-import chalk2 from "chalk";
-var explainCommand = new Command4("explain").description("Look up a node by ID in the manifest").argument("<id>", "node ID to look up").option("--manifest <path>", "path to manifest file", "dist/context.manifest.json").action((id, opts) => {
-  const manifestPath = path4.resolve(process.cwd(), opts.manifest);
-  if (!fs3.existsSync(manifestPath)) {
-    console.error(`Manifest not found at ${manifestPath}. Run 'context build' first.`);
-    process.exit(1);
-  }
-  let manifest;
+import { compile as compile4, loadConfig as loadConfig4 } from "@runcontext/core";
+var explainCommand = new Command4("explain").description("Look up models, terms, or owners by name and show details").argument("<name>", "Name of a model, term, or owner to look up").option("--context-dir <path>", "Path to context directory").option("--format <type>", "Output format: pretty or json", "pretty").action(async (name, opts) => {
   try {
-    const raw = fs3.readFileSync(manifestPath, "utf-8");
-    manifest = JSON.parse(raw);
-  } catch {
-    console.error(`Failed to read manifest at ${manifestPath}`);
-    process.exit(1);
-  }
-  const entry = manifest.indexes?.byId?.[id];
-  if (!entry) {
-    console.error(`Node "${id}" not found in manifest.`);
-    process.exit(1);
-  }
-  const { kind, index } = entry;
-  const collection = manifest[kind + "s"];
-  if (!collection || !collection[index]) {
-    console.error(`Node "${id}" not found in "${kind}s" collection.`);
-    process.exit(1);
-  }
-  const node = collection[index];
-  console.log(chalk2.bold(`${kind}: ${id}`));
-  console.log("");
-  const fields = Object.entries(node).filter(
-    ([key]) => key !== "id"
-  );
-  for (const [key, value] of fields) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      console.log(`  ${chalk2.dim(key + ":")} ${value.join(", ")}`);
-    } else if (typeof value === "object") {
-      console.log(`  ${chalk2.dim(key + ":")} ${JSON.stringify(value)}`);
+    const config = loadConfig4(process.cwd());
+    const contextDir = opts.contextDir ? path4.resolve(opts.contextDir) : path4.resolve(config.context_dir);
+    const { graph } = await compile4({ contextDir, config });
+    const results = [];
+    if (graph.models.has(name)) {
+      results.push({ type: "model", name, data: graph.models.get(name) });
+    }
+    if (graph.terms.has(name)) {
+      results.push({ type: "term", name, data: graph.terms.get(name) });
+    }
+    if (graph.owners.has(name)) {
+      results.push({ type: "owner", name, data: graph.owners.get(name) });
+    }
+    if (graph.governance.has(name)) {
+      results.push({
+        type: "governance",
+        name,
+        data: graph.governance.get(name)
+      });
+    }
+    if (graph.rules.has(name)) {
+      results.push({ type: "rules", name, data: graph.rules.get(name) });
+    }
+    if (graph.lineage.has(name)) {
+      results.push({ type: "lineage", name, data: graph.lineage.get(name) });
+    }
+    if (results.length === 0) {
+      console.error(formatError(`No matching entity found for '${name}'.`));
+      process.exit(1);
+    }
+    if (opts.format === "json") {
+      console.log(formatJson(results));
     } else {
-      console.log(`  ${chalk2.dim(key + ":")} ${String(value)}`);
+      for (const result of results) {
+        console.log(chalk5.bold(`${result.type}: ${result.name}`));
+        console.log(chalk5.gray("---"));
+        console.log(JSON.stringify(result.data, null, 2));
+        console.log("");
+      }
     }
+  } catch (err) {
+    console.error(formatError(err.message));
+    process.exit(1);
   }
 });
 
 // src/commands/fix.ts
 import { Command as Command5 } from "commander";
+import chalk6 from "chalk";
 import path5 from "path";
-import fs4 from "fs";
-import chalk3 from "chalk";
+import fs2 from "fs";
 import {
-  loadConfig as loadConfig3,
-  compile as compile3,
-  LintEngine as LintEngine3,
-  ALL_RULES as ALL_RULES3,
+  compile as compile5,
+  loadConfig as loadConfig5,
+  LintEngine as LintEngine2,
+  ALL_RULES as ALL_RULES2,
   applyFixes
 } from "@runcontext/core";
-var fixCommand = new Command5("fix").description("Apply autofixes to context files").option("--write", "write fixes to disk (default: dry-run)").option("--format <format>", "output format for diagnostics (pretty|json)", "pretty").action(async (opts) => {
+var fixCommand = new Command5("fix").description("Auto-fix lint issues").option("--context-dir <path>", "Path to context directory").option("--format <type>", "Output format: pretty or json", "pretty").option("--dry-run", "Show what would be fixed without writing files").action(async (opts) => {
   try {
-    const config = await loadConfig3(process.cwd());
-    const rootDir = config.paths?.rootDir || process.cwd();
-    const contextDir = path5.resolve(rootDir, config.paths?.contextDir || "context");
-    const { graph, diagnostics: compileDiags } = await compile3({ contextDir, config });
-    const engine = new LintEngine3(config.lint?.rules);
-    for (const rule of ALL_RULES3) {
+    const config = loadConfig5(process.cwd());
+    const contextDir = opts.contextDir ? path5.resolve(opts.contextDir) : path5.resolve(config.context_dir);
+    const { graph } = await compile5({ contextDir, config });
+    const overrides = config.lint?.severity_overrides;
+    const engine = new LintEngine2(overrides);
+    for (const rule of ALL_RULES2) {
       engine.register(rule);
     }
-    const lintDiags = engine.run(graph);
-    const allDiags = [...compileDiags, ...lintDiags];
-    const fixableDiags = allDiags.filter((d) => d.fixable && d.fix);
-    const unfixableDiags = allDiags.filter((d) => !d.fixable || !d.fix);
-    if (fixableDiags.length === 0) {
-      console.log(chalk3.green("No fixable issues found."));
-      if (unfixableDiags.length > 0) {
-        console.log("");
-        console.log(chalk3.yellow(`${unfixableDiags.length} unfixable issue(s) remain:`));
-        const output = opts.format === "json" ? formatDiagnosticsJson(unfixableDiags) : formatDiagnostics(unfixableDiags);
-        console.log(output);
-        const hasErrors = unfixableDiags.some((d) => d.severity === "error");
-        if (hasErrors) {
-          process.exit(1);
-        }
+    const diagnostics = engine.run(graph);
+    const fixable = diagnostics.filter((d) => d.fixable);
+    if (fixable.length === 0) {
+      if (opts.format === "json") {
+        console.log(formatJson({ fixedFiles: [], fixCount: 0 }));
+      } else {
+        console.log(chalk6.green("No fixable issues found."));
       }
       return;
     }
-    const results = applyFixes(fixableDiags);
-    if (opts.write) {
-      for (const result of results) {
-        fs4.writeFileSync(result.file, result.newContent, "utf-8");
+    const readFile = (filePath) => fs2.readFileSync(filePath, "utf-8");
+    const fixedFiles = applyFixes(fixable, readFile);
+    if (opts.dryRun) {
+      if (opts.format === "json") {
+        const entries = [...fixedFiles.entries()].map(([file, content]) => ({
+          file,
+          content
+        }));
+        console.log(
+          formatJson({ dryRun: true, fixCount: fixable.length, entries })
+        );
+      } else {
+        console.log(
+          chalk6.yellow(`Dry run: ${fixable.length} issue(s) would be fixed in ${fixedFiles.size} file(s):`)
+        );
+        for (const file of fixedFiles.keys()) {
+          console.log(chalk6.gray(`  ${file}`));
+        }
       }
-      const totalEdits = results.reduce((sum, r) => sum + r.editsApplied, 0);
+      return;
+    }
+    for (const [file, content] of fixedFiles) {
+      fs2.writeFileSync(file, content, "utf-8");
+    }
+    if (opts.format === "json") {
       console.log(
-        chalk3.green(`Fixed ${totalEdits} issue(s) in ${results.length} file(s).`)
+        formatJson({
+          fixedFiles: [...fixedFiles.keys()],
+          fixCount: fixable.length
+        })
       );
-      if (unfixableDiags.length > 0) {
-        console.log("");
-        console.log(chalk3.yellow(`${unfixableDiags.length} unfixable issue(s) remain:`));
-        const output = opts.format === "json" ? formatDiagnosticsJson(unfixableDiags) : formatDiagnostics(unfixableDiags);
-        console.log(output);
-      }
     } else {
-      console.log(chalk3.cyan("Dry run \u2014 no files changed. Use --write to apply fixes.\n"));
-      console.log(chalk3.bold(`${fixableDiags.length} fixable issue(s) found:
-`));
-      for (const diag of fixableDiags) {
-        const location = `${diag.source.file}:${diag.source.line}:${diag.source.col}`;
-        const severityLabel = diag.severity === "error" ? chalk3.red("error") : chalk3.yellow("warning");
-        console.log(`  ${location}  ${severityLabel}  ${chalk3.dim(diag.ruleId)}  ${diag.message}`);
-        if (diag.fix) {
-          console.log(`    ${chalk3.green("fix:")} ${diag.fix.description}`);
-        }
-      }
-      console.log("");
       console.log(
-        `Would fix ${results.reduce((s, r) => s + r.editsApplied, 0)} issue(s) in ${results.length} file(s).`
+        formatSuccess(
+          `Fixed ${fixable.length} issue(s) in ${fixedFiles.size} file(s).`
+        )
       );
-      if (unfixableDiags.length > 0) {
-        console.log("");
-        console.log(chalk3.yellow(`${unfixableDiags.length} unfixable issue(s) would remain.`));
-      }
-    }
-    const hasUnfixableErrors = unfixableDiags.some((d) => d.severity === "error");
-    if (hasUnfixableErrors) {
-      process.exit(1);
     }
   } catch (err) {
-    console.error("Fix failed:", err.message);
+    console.error(formatError(err.message));
     process.exit(1);
   }
 });
 
 // src/commands/dev.ts
 import { Command as Command6 } from "commander";
+import chalk7 from "chalk";
 import path6 from "path";
-import chalk4 from "chalk";
-import { watch } from "chokidar";
 import {
-  loadConfig as loadConfig4,
-  compile as compile4,
-  LintEngine as LintEngine4,
-  ALL_RULES as ALL_RULES4
+  compile as compile6,
+  loadConfig as loadConfig6,
+  LintEngine as LintEngine3,
+  ALL_RULES as ALL_RULES3
 } from "@runcontext/core";
-var devCommand = new Command6("dev").description("Watch context files and rebuild on change").action(async () => {
+async function runLint(contextDir) {
+  const config = loadConfig6(process.cwd());
+  const { graph, diagnostics: compileDiags } = await compile6({
+    contextDir,
+    config
+  });
+  const overrides = config.lint?.severity_overrides;
+  const engine = new LintEngine3(overrides);
+  for (const rule of ALL_RULES3) {
+    engine.register(rule);
+  }
+  const lintDiags = engine.run(graph);
+  const allDiags = [...compileDiags, ...lintDiags];
+  console.clear();
+  console.log(chalk7.gray(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Linting...`));
+  console.log(formatDiagnostics(allDiags));
+  console.log("");
+}
+var devCommand = new Command6("dev").description("Watch mode \u2014 re-run lint on file changes").option("--context-dir <path>", "Path to context directory").action(async (opts) => {
   try {
-    const config = await loadConfig4(process.cwd());
-    const rootDir = config.paths?.rootDir || process.cwd();
-    const contextDir = path6.resolve(rootDir, config.paths?.contextDir || "context");
-    const watchPattern = path6.join(contextDir, "**/*.{yaml,yml}");
-    console.log(chalk4.cyan(`Watching ${watchPattern} for changes...
-`));
-    await runBuild(contextDir, config);
+    const config = loadConfig6(process.cwd());
+    const contextDir = opts.contextDir ? path6.resolve(opts.contextDir) : path6.resolve(config.context_dir);
+    console.log(chalk7.blue(`Watching ${contextDir} for changes...`));
+    console.log(chalk7.gray("Press Ctrl+C to stop.\n"));
+    await runLint(contextDir);
+    const { watch } = await import("chokidar");
     let debounceTimer = null;
-    const watcher = watch(watchPattern, {
-      ignoreInitial: true,
-      persistent: true
+    const watcher = watch(contextDir, {
+      ignored: /(^|[/\\])\../,
+      // ignore dotfiles
+      persistent: true,
+      ignoreInitial: true
     });
     watcher.on("all", (_event, _filePath) => {
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-      }
+      if (debounceTimer) clearTimeout(debounceTimer);
       debounceTimer = setTimeout(async () => {
-        debounceTimer = null;
-        await runBuild(contextDir, config);
-      }, 100);
-    });
-    watcher.on("error", (error) => {
-      console.error(chalk4.red(`Watcher error: ${error.message}`));
+        try {
+          await runLint(contextDir);
+        } catch (err) {
+          console.error(
+            chalk7.red(`Lint error: ${err.message}`)
+          );
+        }
+      }, 300);
     });
-    const cleanup = () => {
-      console.log(chalk4.dim("\nStopping watch mode..."));
-      watcher.close().then(() => {
-        process.exit(0);
-      });
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
   } catch (err) {
-    console.error("Dev mode failed:", err.message);
+    console.error(chalk7.red(`Dev mode failed: ${err.message}`));
     process.exit(1);
   }
 });
-async function runBuild(contextDir, config) {
-  const separator = chalk4.dim("\u2500".repeat(60));
-  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
-  console.log(separator);
-  console.log(chalk4.bold(`[${timestamp}] Rebuilding...
-`));
+
+// src/commands/init.ts
+import { Command as Command7 } from "commander";
+import chalk8 from "chalk";
+import path7 from "path";
+import fs3 from "fs";
+var EXAMPLE_OSI = `version: "1.0"
+
+semantic_model:
+  - name: example-model
+    description: An example semantic model
+    ai_context:
+      instructions: "Use this model for general analytics queries"
+      synonyms: ["example", "sample model"]
+
+    datasets:
+      - name: example_table
+        source: warehouse.public.example_table
+        primary_key: [id]
+        description: "Example table"
+        fields:
+          - name: id
+            expression:
+              dialects:
+                - dialect: ANSI_SQL
+                  expression: id
+            description: "Primary key"
+            type: number
+          - name: name
+            expression:
+              dialects:
+                - dialect: ANSI_SQL
+                  expression: name
+            description: "Name field"
+            type: string
+`;
+var EXAMPLE_GOVERNANCE = `model: example-model
+owner: data-team
+classification: internal
+security:
+  pii: false
+  access_level: internal
+datasets:
+  example_table:
+    grain: one row per example entity
+    fields:
+      id:
+        description: "Primary key"
+      name:
+        description: "Name field"
+`;
+var EXAMPLE_TERM = `glossary:
+  - term: Example Term
+    definition: A sample glossary term to demonstrate the format
+    aliases: ["sample term"]
+    owner: data-team
+`;
+var EXAMPLE_OWNER = `team: data-team
+name: Data Team
+email: data-team@example.com
+slack: "#data-team"
+members:
+  - name: Jane Doe
+    role: lead
+`;
+var EXAMPLE_CONFIG = `context_dir: context
+output_dir: dist
+minimum_tier: bronze
+`;
+var initCommand = new Command7("init").description("Scaffold a v0.2 ContextKit project structure").option("--dir <path>", "Root directory for the project", ".").action(async (opts) => {
   try {
-    const { graph, diagnostics: compileDiags } = await compile4({ contextDir, config });
-    const engine = new LintEngine4(config.lint?.rules);
-    for (const rule of ALL_RULES4) {
-      engine.register(rule);
+    const rootDir = path7.resolve(opts.dir);
+    const contextDir = path7.join(rootDir, "context");
+    const dirs = [
+      path7.join(contextDir, "models"),
+      path7.join(contextDir, "governance"),
+      path7.join(contextDir, "glossary"),
+      path7.join(contextDir, "owners")
+    ];
+    for (const dir of dirs) {
+      fs3.mkdirSync(dir, { recursive: true });
     }
-    const lintDiags = engine.run(graph);
-    const allDiags = [...compileDiags, ...lintDiags];
-    if (allDiags.length === 0) {
-      console.log(chalk4.green("No issues found.\n"));
-      return;
-    }
-    let errorCount = 0;
-    let warningCount = 0;
-    let fixableCount = 0;
-    for (const d of allDiags) {
-      if (d.severity === "error") errorCount++;
-      else warningCount++;
-      if (d.fixable) fixableCount++;
-      const location = `${d.source.file}:${d.source.line}:${d.source.col}`;
-      const severityLabel = d.severity === "error" ? chalk4.red("error") : chalk4.yellow("warning");
-      console.log(`  ${location}  ${severityLabel}  ${chalk4.dim(d.ruleId)}  ${d.message}`);
+    const files = [
+      {
+        path: path7.join(contextDir, "models", "example-model.osi.yaml"),
+        content: EXAMPLE_OSI
+      },
+      {
+        path: path7.join(
+          contextDir,
+          "governance",
+          "example-model.governance.yaml"
+        ),
+        content: EXAMPLE_GOVERNANCE
+      },
+      {
+        path: path7.join(contextDir, "glossary", "glossary.term.yaml"),
+        content: EXAMPLE_TERM
+      },
+      {
+        path: path7.join(contextDir, "owners", "data-team.owner.yaml"),
+        content: EXAMPLE_OWNER
+      },
+      {
+        path: path7.join(rootDir, "contextkit.config.yaml"),
+        content: EXAMPLE_CONFIG
+      }
+    ];
+    let created = 0;
+    let skipped = 0;
+    for (const file of files) {
+      if (fs3.existsSync(file.path)) {
+        console.log(chalk8.gray(`  skip ${path7.relative(rootDir, file.path)} (exists)`));
+        skipped++;
+      } else {
+        fs3.writeFileSync(file.path, file.content, "utf-8");
+        console.log(chalk8.green(`  create ${path7.relative(rootDir, file.path)}`));
+        created++;
+      }
     }
     console.log("");
-    const parts = [];
-    if (errorCount > 0) {
-      parts.push(chalk4.red(`${errorCount} error${errorCount !== 1 ? "s" : ""}`));
-    }
-    if (warningCount > 0) {
-      parts.push(chalk4.yellow(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`));
-    }
-    if (fixableCount > 0) {
-      parts.push(chalk4.cyan(`${fixableCount} fixable`));
-    }
-    console.log(parts.join(", ") + "\n");
+    console.log(
+      formatSuccess(
+        `Initialized ContextKit project: ${created} file(s) created, ${skipped} skipped.`
+      )
+    );
+    console.log("");
+    console.log(chalk8.gray("Next steps:"));
+    console.log(chalk8.gray("  1. Edit the example files in context/"));
+    console.log(chalk8.gray("  2. Run: context lint"));
+    console.log(chalk8.gray("  3. Run: context build"));
   } catch (err) {
-    console.error(chalk4.red(`Build error: ${err.message}
-`));
+    console.error(formatError(err.message));
+    process.exit(1);
   }
-}
+});
 
 // src/commands/site.ts
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { Command as Command7 } from "commander";
-import { generateSite } from "@runcontext/site";
-var siteCommand = new Command7("site").description("Site generator commands");
-siteCommand.command("build").description("Build the context documentation site").option("--manifest <path>", "Path to manifest file", "dist/context.manifest.json").option("--output <dir>", "Output directory", "dist/site").option("--title <title>", "Site title").option("--base-path <path>", "Base path for links (e.g., /docs)").action(async (opts) => {
-  const manifestPath = resolve(opts.manifest);
-  let manifestJson;
-  try {
-    manifestJson = await readFile(manifestPath, "utf-8");
-  } catch {
-    console.error(`Error: Could not read manifest file at ${manifestPath}`);
-    console.error('Run "context build" first to generate the manifest.');
-    process.exitCode = 1;
-    return;
-  }
-  let manifest;
+import { Command as Command8 } from "commander";
+import chalk9 from "chalk";
+import path8 from "path";
+import { compile as compile7, loadConfig as loadConfig7, emitManifest as emitManifest2 } from "@runcontext/core";
+var siteCommand = new Command8("site").description("Build a static documentation site from compiled context").option("--context-dir <path>", "Path to context directory").option("--output-dir <path>", "Path to site output directory").action(async (opts) => {
   try {
-    manifest = JSON.parse(manifestJson);
-  } catch {
-    console.error(`Error: Invalid JSON in manifest file at ${manifestPath}`);
-    process.exitCode = 1;
-    return;
+    const config = loadConfig7(process.cwd());
+    const contextDir = opts.contextDir ? path8.resolve(opts.contextDir) : path8.resolve(config.context_dir);
+    const { graph } = await compile7({ contextDir, config });
+    const manifest = emitManifest2(graph, config);
+    let buildSite;
+    try {
+      const siteModule = await import("@runcontext/site");
+      buildSite = siteModule.buildSite;
+    } catch {
+    }
+    if (!buildSite) {
+      console.log(
+        chalk9.yellow(
+          "Site generator is not yet available. Install @runcontext/site to enable this command."
+        )
+      );
+      process.exit(0);
+    }
+    const outputDir = opts.outputDir ? path8.resolve(opts.outputDir) : path8.resolve(config.site?.base_path ?? "site");
+    await buildSite(manifest, config, outputDir);
+    console.log(chalk9.green(`Site built to ${outputDir}`));
+  } catch (err) {
+    console.error(formatError(err.message));
+    process.exit(1);
   }
-  const outputDir = resolve(opts.output);
-  console.log(`Building site from ${manifestPath}...`);
-  await generateSite({
-    manifest,
-    outputDir,
-    title: opts.title,
-    basePath: opts.basePath
-  });
-  console.log(`Site generated at ${outputDir}`);
 });
 
 // src/commands/serve.ts
-import { Command as Command8 } from "commander";
-import fs5 from "fs";
-import path7 from "path";
-var serveCommand = new Command8("serve").description("Start the MCP server").option("--stdio", "Use stdio transport (default)").option("--http <port>", "Use HTTP/SSE transport on the given port", parseInt).option("--manifest <path>", "Path to manifest file", "dist/context.manifest.json").action(async (opts) => {
+import { Command as Command9 } from "commander";
+import chalk10 from "chalk";
+var serveCommand = new Command9("serve").description("Start the MCP server (stdio transport)").option("--context-dir <path>", "Path to context directory").action(async (opts) => {
   try {
-    const manifestPath = path7.resolve(process.cwd(), opts.manifest);
-    if (!fs5.existsSync(manifestPath)) {
-      console.error(`Manifest not found: ${manifestPath}`);
-      console.error('Run "context build" first to generate the manifest.');
+    let startServer;
+    try {
+      const mcpModule = await import("@runcontext/mcp");
+      startServer = mcpModule.startServer;
+    } catch {
+    }
+    if (!startServer) {
+      console.log(
+        chalk10.yellow(
+          "MCP server is not available. Install @runcontext/mcp to enable this command."
+        )
+      );
       process.exit(1);
     }
-    const manifestData = JSON.parse(fs5.readFileSync(manifestPath, "utf-8"));
-    const { createContextMcpServer } = await import("@runcontext/mcp");
-    const server = createContextMcpServer(manifestData);
-    if (opts.http) {
-      const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
-      const { createMcpExpressApp } = await import("@modelcontextprotocol/sdk/server/express.js");
-      const { randomUUID } = await import("crypto");
-      const app = createMcpExpressApp();
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID()
-      });
-      app.all("/mcp", (req, res) => {
-        transport.handleRequest(req, res);
-      });
-      await server.connect(transport);
-      const port = opts.http;
-      app.listen(port, () => {
-        console.log(`ContextKit MCP server listening on http://127.0.0.1:${port}/mcp`);
-      });
+    console.log(chalk10.blue("Starting MCP server (stdio transport)..."));
+    await startServer({
+      contextDir: opts.contextDir,
+      rootDir: process.cwd()
+    });
+  } catch (err) {
+    console.error(formatError(err.message));
+    process.exit(1);
+  }
+});
+
+// src/commands/validate-osi.ts
+import { Command as Command10 } from "commander";
+import chalk11 from "chalk";
+import path9 from "path";
+import { parseFile, osiDocumentSchema } from "@runcontext/core";
+var validateOsiCommand = new Command10("validate-osi").description("Validate a single OSI file against the schema").argument("<file>", "Path to the OSI YAML file").option("--format <type>", "Output format: pretty or json", "pretty").action(async (file, opts) => {
+  try {
+    const filePath = path9.resolve(file);
+    const parsed = await parseFile(filePath, "model");
+    const result = osiDocumentSchema.safeParse(parsed.data);
+    if (result.success) {
+      if (opts.format === "json") {
+        console.log(
+          formatJson({
+            valid: true,
+            file: filePath,
+            data: result.data
+          })
+        );
+      } else {
+        console.log(formatSuccess(`${filePath} is valid.`));
+      }
     } else {
-      const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
-      console.error("ContextKit MCP server running on stdio");
+      const issues = result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message
+      }));
+      if (opts.format === "json") {
+        console.log(
+          formatJson({
+            valid: false,
+            file: filePath,
+            issues
+          })
+        );
+      } else {
+        console.error(chalk11.red(`Validation failed for ${filePath}:`));
+        for (const issue of issues) {
+          console.error(chalk11.red(`  ${issue.path}: ${issue.message}`));
+        }
+      }
+      process.exit(1);
     }
   } catch (err) {
-    console.error("Failed to start MCP server:", err.message);
+    console.error(formatError(err.message));
     process.exit(1);
   }
 });
 
 // src/index.ts
-var program = new Command9();
-program.name("context").version("0.1.0").description("ContextKit \u2014 Git-native institutional context compiler");
-program.addCommand(buildCommand);
+var program = new Command11();
+program.name("context").description("ContextKit \u2014 AI-ready metadata governance over OSI").version("0.2.0");
 program.addCommand(lintCommand);
-program.addCommand(initCommand);
+program.addCommand(buildCommand);
+program.addCommand(tierCommand);
 program.addCommand(explainCommand);
 program.addCommand(fixCommand);
 program.addCommand(devCommand);
+program.addCommand(initCommand);
 program.addCommand(siteCommand);
 program.addCommand(serveCommand);
-await program.parseAsync(process.argv);
+program.addCommand(validateOsiCommand);
+program.parse();
 //# sourceMappingURL=index.js.map