@aikdna/kdna-cli 0.19.2 → 0.20.0

package/src/cmds/protocol.js

@@ -0,0 +1,181 @@
+const { readFileSync } = require('fs');
+const path = require('path');
+const { error, EXIT } = require('./_common');
+
+const SCHEMA_DIR = path.join(
+  path.dirname(require.resolve('@aikdna/kdna-core/package.json')),
+  '..',
+  '..',
+  'specs',
+);
+
+const SCHEMAS = {
+  'artifact-envelope': 'artifact-envelope.schema.json',
+  'stage-definition': 'stage-definition.schema.json',
+  'fidelity-result': 'fidelity-result.schema.json',
+  'product-runtime': 'product-runtime.schema.json',
+};
+
+function validate(args) {
+  const file = args.filter((a) => !a.startsWith('--'))[1];
+  const schemaName = args.includes('--schema') ? args[args.indexOf('--schema') + 1] : null;
+
+  if (!file) {
+    error('Usage: kdna protocol validate <file.json> [--schema <name>]', EXIT.INPUT_ERROR);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    error(`Failed to read or parse ${file}: ${e.message}`, EXIT.INPUT_ERROR);
+  }
+
+  const schemasToCheck = schemaName ? [schemaName] : Object.keys(SCHEMAS);
+  let passed = 0;
+  let failed = 0;
+
+  for (const name of schemasToCheck) {
+    const schemaFile = SCHEMAS[name];
+    if (!schemaFile) {
+      error(
+        `Unknown schema: ${name}. Available: ${Object.keys(SCHEMAS).join(', ')}`,
+        EXIT.INPUT_ERROR,
+      );
+    }
+
+    try {
+      const schemaPath = path.join(SCHEMA_DIR, schemaFile);
+      const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+      const { validate: ajvValidate } = loadAjv();
+      const valid = ajvValidate(schema, data);
+      if (valid) {
+        console.log(`  ✓ ${name} (${schemaFile})`);
+        passed++;
+      } else {
+        console.log(`  ✗ ${name} (${schemaFile})`);
+        failed++;
+      }
+    } catch (e) {
+      console.log(`  ✗ ${name}: ${e.message}`);
+      failed++;
+    }
+  }
+
+  if (failed > 0) {
+    error(`Validation failed: ${failed}/${passed + failed} schema(s)`, EXIT.VALIDATION_FAILED);
+  }
+  console.log(`Validation passed: ${passed}/${passed + failed} schema(s)`);
+}
+
+function inspect(args) {
+  const file = args.filter((a) => !a.startsWith('--'))[1];
+  if (!file) {
+    error('Usage: kdna protocol inspect <file.json>', EXIT.INPUT_ERROR);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(readFileSync(file, 'utf8'));
+  } catch (e) {
+    error(`Failed to read ${file}: ${e.message}`, EXIT.INPUT_ERROR);
+  }
+
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(summarize(data), null, 2));
+  } else {
+    const summary = summarize(data);
+    console.log(`Type: ${summary.type}`);
+    if (summary.artifact_type) console.log(`Artifact: ${summary.artifact_type}`);
+    if (summary.generator)
+      console.log(`Generator: ${summary.generator.engine} v${summary.generator.version}`);
+    if (summary.source_kdna_count) console.log(`KDNA domains: ${summary.source_kdna_count}`);
+    if (summary.stages_count) console.log(`Stages: ${summary.stages_count}`);
+    if (summary.quality) console.log(`Quality: ${summary.quality}`);
+    if (summary.fidelity) console.log(`Fidelity: ${summary.fidelity}`);
+    if (summary.review) console.log(`Review: ${summary.review}`);
+  }
+}
+
+function summarize(data) {
+  const summary = { type: 'unknown' };
+
+  if (data.format === 'kdna-pipeline') {
+    summary.type = 'pipeline';
+    summary.stages_count = data.stages?.length || 0;
+    if (data.pipeline_kdna) summary.kdna_mode = data.pipeline_kdna.mode;
+    if (data.artifacts?.enabled) summary.artifacts_enabled = true;
+    if (data.trace?.enabled) summary.trace_enabled = true;
+  } else if (data.artifact_id && data.artifact_type) {
+    summary.type = 'artifact';
+    summary.artifact_type = data.artifact_type;
+    if (data.generator) summary.generator = data.generator;
+    summary.source_kdna_count = data.source_kdna?.length || 0;
+    if (data.quality?.overall_result) summary.quality = data.quality.overall_result;
+    if (data.review?.status) summary.review = data.review.status;
+    if (data.quality?.fidelity?.score !== undefined)
+      summary.fidelity = `${data.quality.fidelity.score} (v${data.quality.fidelity.protocol_version})`;
+  } else if (
+    data.fidelity_id &&
+    (data.protocol_version !== undefined || data.protocolVersion !== undefined)
+  ) {
+    summary.type = 'fidelity_result';
+    summary.overall_score = data.overall_score ?? data.overallScore;
+    summary.passed = data.passed;
+    const cmp = data.comparison;
+    if (cmp) {
+      if (cmp.blind_delta !== undefined) summary.blind_delta = cmp.blind_delta;
+      else if (cmp.blindDelta !== undefined) summary.blind_delta = cmp.blindDelta;
+    }
+  } else if (data.format === 'kdna-product-runtime') {
+    summary.type = 'product_runtime';
+    if (data.schedule) summary.schedule_type = data.schedule.type;
+    if (data.selection) summary.selection_type = data.selection.type;
+  }
+
+  return summary;
+}
+
+let _ajv = null;
+function loadAjv() {
+  if (_ajv) return _ajv;
+  try {
+    const Ajv = require('ajv');
+    const addFormats = require('ajv-formats');
+    const ajv = new Ajv({ allErrors: true, strict: false, validateSchema: false });
+    addFormats(ajv);
+    _ajv = { ajv, validate: (schema, data) => ajv.validate(schema, data) };
+  } catch {
+    _ajv = {
+      validate: () => {
+        throw new Error('ajv not installed. Run: npm install ajv ajv-formats');
+      },
+    };
+  }
+  return _ajv;
+}
+
+function cmdProtocol(args) {
+  const sub = args[1];
+  const rest = args.slice(1);
+
+  switch (sub) {
+    case 'validate':
+      validate(rest);
+      break;
+    case 'inspect':
+      inspect(rest);
+      break;
+    default:
+      error(
+        'Usage: kdna protocol <validate|inspect> [file]\n' +
+          '  kdna protocol validate <file.json> [--schema <name>]\n' +
+          '  kdna protocol inspect <file.json> [--json]\n' +
+          '\nSchemas: ' +
+          Object.keys(SCHEMAS).join(', '),
+        EXIT.INPUT_ERROR,
+      );
+  }
+}
+
+module.exports = { cmdProtocol };

package/src/cmds/studio.js

@@ -1,11 +1,11 @@
 /**
- * KDNA Studio CLI commands — Phase 1: Studio Beta 底层支撑.
+ * Dev-only Studio project diagnostics retained for old project files.
  *
- *   kdna studio scaffold <name>         Create Studio project skeleton
+ *   kdna-studio create <name>         Create Studio project skeleton
  *   kdna cards validate <project.json>  Validate Judgment Cards
  *   kdna lock verify <project.json>     Verify Human Lock status
- *   kdna studio compile <project.json>  Compile locked cards into KDNA domain
- *   kdna studio readiness <project.json>  Generate Domain Readiness Card
+ *   kdna-studio compile <project.json>  Compile locked cards into Studio build output
+ *   kdna-studio report <project.json>  Generate Domain Readiness Card
  */
 
 const fs = require('fs');
@@ -80,10 +80,7 @@ const CARD_TEMPLATES = {
 
 function cmdStudioScaffold(name, args = []) {
   if (!name)
-    error(
-      'Usage: kdna studio scaffold <name> [--type=domain|cluster] [--minimal]',
-      EXIT.INPUT_ERROR,
-    );
+    error('Usage: kdna-studio create <name> [--type=domain|cluster] [--minimal]', EXIT.INPUT_ERROR);
   if (!/^[a-z][a-z0-9_-]*$/.test(name)) {
     error(
       `Invalid name "${name}". Use lowercase letters, numbers, hyphens, underscores. Start with letter.`,
@@ -139,7 +136,7 @@ function cmdStudioScaffold(name, args = []) {
   // Write exports/README.md
   fs.writeFileSync(
     path.join(targetDir, 'exports', 'README.md'),
-    `# ${name}\n\nCompiled KDNA domain files will appear here after \`kdna studio compile\`.\n`,
+    `# ${name}\n\nCompiled KDNA domain files will appear here after \`kdna-studio compile\`.\n`,
   );
 
   console.log(`✓ Studio project created: ${targetDir}/`);
@@ -150,7 +147,7 @@ function cmdStudioScaffold(name, args = []) {
   console.log('  1. Edit cards/ — replace all [TODO] placeholders');
   console.log('  2. Run: kdna cards validate studio.project.json');
   console.log('  3. Run: kdna lock verify studio.project.json');
-  console.log('  4. Run: kdna studio compile studio.project.json');
+  console.log('  4. Run: kdna-studio compile studio.project.json');
 }
 
 // ─── Cards Validate ───────────────────────────────────────────────────