hive-lite 0.1.9 → 0.2.0

package/src/cli.js

@@ -1,10 +1,13 @@
+const fs = require('fs');
 const path = require('path');
 const { version: packageVersion } = require('../package.json');
 const { requireGitRepo } = require('./lib/git');
 const { evaluateMapHealth } = require('./lib/health');
+const { readIntentTarget, saveStartIntent, validateIntentTarget } = require('./lib/intent');
 const { createMapPrompt, initProject, loadProjectMap, suggestMap, verifyProjectMap } = require('./lib/map');
 const { createContextPacket } = require('./lib/context');
 const { evaluateNextAction } = require('./lib/next');
+const { runOperator } = require('./lib/operator');
 const { installSkills, skillsDoctor, syncSkills } = require('./lib/skills');
 const { patternDisplay } = require('./lib/scope');
 const { evaluateWorkspaceStatus } = require('./lib/status');
@@ -73,6 +76,12 @@ Usage:
   hive-lite skills doctor [--agent codex|claude|gemini|all] [--path <skills-dir>] [--json]
   hive-lite skills install --agent codex|claude|gemini|all [--force] [--dry-run] [--json]
   hive-lite skills sync --agent codex|claude|gemini|all [--dry-run] [--json]
+  hive-lite intent save --from <file> --json
+  hive-lite intent save --stdin --json
+  hive-lite intent validate <intent_id_or_path> --json
+  hive-lite intent show <intent_id_or_path> --json
+  hive-lite operator run "<clear requirement>" [--operator-agent-command "..."] [--operator-agent-mode stdin|prompt_file]
+  hive-lite operator run --intent <intent_id_or_path> [--operator-agent-command "..."] [--operator-agent-mode stdin|prompt_file]
   hive-lite find "<intent>" [--area <id>] [--max-files 8] [--explain] [--json]
   hive-lite check [changeId] [--context ctx_id] [--json]
   hive-lite validate [changeId] [--cmd "..."] [--profile <id>]
@@ -223,10 +232,12 @@ function printContext(result) {
     console.log('');
     console.log('Candidate Phase Seeds:');
     for (const item of packet.candidatePhaseSeeds) {
+      const fromSplit = packet.splitNote && packet.splitNote.id ? ` --from-split ${packet.splitNote.id}` : '';
       console.log(`  - ${item.id} (${item.areaId})`);
-      console.log(`    find: ${item.findIntent}`);
-      if (item.evidenceClasses && item.evidenceClasses.length > 0) console.log(`    evidence: ${item.evidenceClasses.join(', ')}`);
-      if (item.validationProfiles && item.validationProfiles.length > 0) console.log(`    validation: ${item.validationProfiles.join(', ')}`);
+      console.log('    copyable find command:');
+      console.log(`      hive-lite find ${JSON.stringify(item.findIntent)}${fromSplit} --phase ${item.id} --area ${item.areaId}`);
+      if (item.evidenceClasses && item.evidenceClasses.length > 0) console.log(`    expected evidence: ${item.evidenceClasses.join(', ')}`);
+      if (item.validationProfiles && item.validationProfiles.length > 0) console.log(`    expected validation: ${item.validationProfiles.join(', ')}`);
       console.log(`    risk: ${item.risk}`);
     }
   }
@@ -240,6 +251,15 @@ function printContext(result) {
       console.log('  blocking:');
       for (const item of packet.writePlan.blockingWarnings) console.log(`    - ${item.code}: ${item.message}`);
     }
+    if (packet.writePlan.selectedWritableCertificates && packet.writePlan.selectedWritableCertificates.length > 0) {
+      console.log('  certified direct:');
+      for (const item of packet.writePlan.selectedWritableCertificates) {
+        const artifact = item.artifact ? ` ${item.artifact}` : '';
+        const target = item.targetIdentity ? ` for ${item.targetIdentity}` : '';
+        console.log(`    - ${item.path}: ${item.operation}${artifact}${target}`);
+        if (item.certifiedBy && item.certifiedBy.mapEntry) console.log(`      certified by: ${item.certifiedBy.mapEntry}`);
+      }
+    }
   }
   if (packet.writePlan && packet.writePlan.referenceFiles && packet.writePlan.referenceFiles.length > 0) {
     console.log('');
@@ -396,6 +416,18 @@ function printCheck(root, result) {
       console.log('  selected direct:');
       for (const item of change.writePlanStatus.selectedWritableDirect) console.log(`    - ${item}`);
     }
+    if (change.writePlanStatus.selectedWritableCertificates && change.writePlanStatus.selectedWritableCertificates.length > 0) {
+      console.log('  certificates:');
+      for (const item of change.writePlanStatus.selectedWritableCertificates) {
+        const artifact = item.artifact ? ` ${item.artifact}` : '';
+        const target = item.targetIdentity ? ` for ${item.targetIdentity}` : '';
+        console.log(`    - ${item.path}: ${item.operation}${artifact}${target}`);
+      }
+    }
+    if (change.writePlanStatus.uncertifiedWrites && change.writePlanStatus.uncertifiedWrites.length > 0) {
+      console.log('  uncertified writes:');
+      for (const item of change.writePlanStatus.uncertifiedWrites) console.log(`    - ${item.path}: ${item.operation}`);
+    }
     if (change.writePlanStatus.referenceOnlyTouched && change.writePlanStatus.referenceOnlyTouched.length > 0) {
       console.log('  reference-only touched:');
       for (const item of change.writePlanStatus.referenceOnlyTouched) console.log(`    - ${item.path}: ${item.reason || item.reference}`);
@@ -792,6 +824,56 @@ function printSkillsMutation(result) {
   }
 }
 
+function printIntentErrors(result) {
+  if (result.errors && result.errors.length > 0) {
+    console.log('');
+    console.log('Errors:');
+    for (const error of result.errors) console.log(`  - ${error.code}: ${error.message}`);
+  }
+  if (result.warnings && result.warnings.length > 0) {
+    console.log('');
+    console.log('Warnings:');
+    for (const warning of result.warnings) console.log(`  - ${warning.code}: ${warning.message}`);
+  }
+}
+
+function printIntentSave(result) {
+  if (!result.saved) {
+    console.log('Start Intent Handoff not saved.');
+    printIntentErrors(result);
+    return;
+  }
+  console.log('Start Intent Handoff saved.');
+  console.log('');
+  console.log(`Intent: ${result.intent_id}`);
+  console.log(`Path: ${result.paths.markdown}`);
+  console.log(`JSON: ${result.paths.json}`);
+  if (result.warnings && result.warnings.length > 0) printIntentErrors({ errors: [], warnings: result.warnings });
+  console.log('');
+  console.log('Next (run from this repo root in your terminal):');
+  console.log(`  hive-lite operator run --intent ${result.intent_id}`);
+  console.log('');
+  console.log('Equivalent path form:');
+  console.log(`  hive-lite operator run --intent ${result.paths.markdown}`);
+}
+
+function printIntentValidate(result) {
+  console.log(`Start Intent Handoff: ${result.intent_id || '(unknown)'}`);
+  console.log(`Status: ${result.valid ? 'valid' : 'invalid'}`);
+  console.log(`Path: ${result.paths.markdown}`);
+  printIntentErrors(result);
+}
+
+function printIntentShow(result) {
+  console.log(`Start Intent Handoff: ${result.intent_id || '(unknown)'}`);
+  console.log(`Status: ${result.status || '(unknown)'}`);
+  console.log(`Path: ${result.paths.markdown}`);
+  console.log('');
+  console.log('Find Intent:');
+  console.log(result.findIntent || '(none)');
+  printIntentErrors(result.validation || {});
+}
+
 async function main(argv) {
   const [command, subcommand, subsubcommand, ...rest] = argv;
   if (!command || isHelpArg(command)) {
@@ -862,6 +944,67 @@ async function main(argv) {
     throw new Error('skills requires a subcommand: doctor, install, or sync');
   }
 
+  if (command === 'intent') {
+    const root = requireGitRepo(process.cwd(), 'hive-lite intent');
+    const parsed = parseArgs([subsubcommand, ...rest].filter((item) => item !== undefined));
+
+    if (subcommand === 'save') {
+      if (parsed.flags.from && parsed.flags.stdin) throw new Error('intent save accepts either --from <file> or --stdin, not both');
+      if (!parsed.flags.from && !parsed.flags.stdin) throw new Error('intent save requires --from <file> or --stdin');
+      const source = parsed.flags.stdin ? 'stdin' : parsed.flags.from;
+      const markdown = parsed.flags.stdin
+        ? fs.readFileSync(0, 'utf8')
+        : fs.readFileSync(path.resolve(process.cwd(), parsed.flags.from), 'utf8');
+      const result = saveStartIntent(root, markdown, { source });
+      if (parsed.flags.json) console.log(JSON.stringify(result, null, 2));
+      else printIntentSave(result);
+      if (!result.saved) process.exitCode = 1;
+      return;
+    }
+
+    if (subcommand === 'validate') {
+      const target = parsed.positional[0];
+      if (!target) throw new Error('intent validate requires an intent id or path');
+      const result = validateIntentTarget(root, process.cwd(), target);
+      if (parsed.flags.json) console.log(JSON.stringify(result, null, 2));
+      else printIntentValidate(result);
+      if (!result.valid) process.exitCode = 1;
+      return;
+    }
+
+    if (subcommand === 'show') {
+      const target = parsed.positional[0];
+      if (!target) throw new Error('intent show requires an intent id or path');
+      const result = readIntentTarget(root, process.cwd(), target);
+      if (parsed.flags.json) console.log(JSON.stringify(result, null, 2));
+      else printIntentShow(result);
+      return;
+    }
+
+    throw new Error('intent requires a subcommand: save, validate, or show');
+  }
+
+  if (command === 'operator') {
+    if (subcommand !== 'run') throw new Error('operator requires a subcommand: run');
+    const root = requireGitRepo(process.cwd(), 'hive-lite operator run');
+    const parsed = parseArgs([subsubcommand, ...rest].filter((item) => item !== undefined));
+    if (parsed.flags.intent && parsed.positional.length > 0) {
+      throw new Error('operator run accepts either a clear requirement or --intent, not both');
+    }
+    await runOperator(process.cwd(), {
+      root,
+      requirement: parsed.positional.join(' ').trim(),
+      intent: parsed.flags.intent || null,
+      operatorAgentCommand: parsed.flags.operatorAgentCommand || parsed.flags.agentCommand,
+      operatorAgentMode: parsed.flags.operatorAgentMode || parsed.flags.agentMode,
+    }, {
+      stdin: process.stdin,
+      stdout: process.stdout,
+      stderr: process.stderr,
+    });
+    return;
+  }
+
   if (command === 'find') {
     const parsed = parseArgs([subcommand, subsubcommand, ...rest].filter((item) => item !== undefined));
     const intent = parsed.positional.join(' ').trim();

package/src/lib/change.js

@@ -16,6 +16,12 @@ function sha256(value) {
   return createHash('sha256').update(value || '').digest('hex');
 }
 
+function looksLikeFilePattern(pattern) {
+  if (String(pattern || '').includes('*')) return false;
+  const base = path.basename(String(pattern || ''));
+  return /\.[A-Za-z0-9]+$/.test(base);
+}
+
 function changeDir(root, id) {
   return path.join(hiveDir(root), 'changes', id);
 }
@@ -314,6 +320,61 @@ function validationPlanFromContextOrMap(context, map) {
   }] : [];
 }
 
+function createPatternsFromContext(context) {
+  const scope = context && context.scope ? context.scope : {};
+  return normalizePatternList(scope.writableCreatePatterns || [], {
+    source: 'writable_create_patterns',
+    operations: ['create_file'],
+  }).map(itemPattern).filter(Boolean);
+}
+
+function selectedWritableCertificatesFromContext(context) {
+  const writePlan = context && context.writePlan ? context.writePlan : null;
+  return writePlan && Array.isArray(writePlan.selectedWritableCertificates)
+    ? writePlan.selectedWritableCertificates
+    : [];
+}
+
+function certificateOperation(certificate) {
+  return certificate.operation || certificate.operationKind || null;
+}
+
+function certificatePath(certificate) {
+  return certificate.path || certificate.scope || certificate.pattern || null;
+}
+
+function certificateCoversFile(certificate, file, operation) {
+  const pattern = certificatePath(certificate);
+  if (!pattern || !matchesPattern(file, pattern)) return false;
+  const certifiedOperation = certificateOperation(certificate);
+  if (!certifiedOperation) return true;
+  return certifiedOperation === operation;
+}
+
+function matchesReviewGatedScope(file, context) {
+  const scope = context && context.scope ? context.scope : {};
+  const reviewGated = [
+    ...normalizePatternList(scope.writableConditional || [], { requiresReview: true }),
+    ...normalizePatternList(scope.writableBroadFallback || [], { requiresReview: true }),
+  ];
+  return reviewGated.some((item) => matchesPattern(file, itemPattern(item)));
+}
+
+function selectedHasCreatePermission(file, context, selectedWritableDirect, selectedWritableCertificates = []) {
+  if (selectedWritableCertificates.length > 0) {
+    return selectedWritableCertificates.some((certificate) => certificateCoversFile(certificate, file, 'create_file'));
+  }
+  const selected = selectedWritableDirect || [];
+  const selectedSet = new Set(selected);
+  const createPatterns = createPatternsFromContext(context);
+  if (createPatterns.some((pattern) => selectedSet.has(pattern) && matchesPattern(file, pattern))) return true;
+
+  return selected.some((pattern) => (
+    !looksLikeFilePattern(pattern)
+    && matchesPattern(file, pattern)
+  ));
+}
+
 function evaluateWritePlanStatus(files, context) {
   if (!context) {
     return {
@@ -321,7 +382,10 @@ function evaluateWritePlanStatus(files, context) {
       contextMode: null,
       blockingReasons: [],
       selectedWritableDirect: [],
+      selectedWritableCertificates: [],
       referenceOnlyTouched: [],
+      unknownNewFiles: [],
+      uncertifiedWrites: [],
       requiredWrites: [],
       blockingWarnings: [],
     };
@@ -332,9 +396,12 @@ function evaluateWritePlanStatus(files, context) {
     ? writePlan.blockingWarnings
     : [];
   const selectedWritableDirect = Array.isArray(context.writableScope) ? context.writableScope : [];
+  const selectedWritableCertificates = selectedWritableCertificatesFromContext(context);
   const changedPaths = files.map((item) => item.path || item);
   const referenceFiles = writePlan && Array.isArray(writePlan.referenceFiles) ? writePlan.referenceFiles : [];
   const referenceOnlyTouched = [];
+  const unknownNewFiles = [];
+  const uncertifiedWrites = [];
   for (const file of changedPaths) {
     const reference = referenceFiles.find((item) => matchesPattern(file, item.path || item.pattern));
     if (reference) {
@@ -345,6 +412,23 @@ function evaluateWritePlanStatus(files, context) {
       });
     }
   }
+  for (const file of files) {
+    const filePath = file.path || file;
+    if (file.status !== 'untracked') continue;
+    if (!selectedHasCreatePermission(filePath, context, selectedWritableDirect, selectedWritableCertificates)) unknownNewFiles.push(filePath);
+  }
+  if (selectedWritableCertificates.length > 0) {
+    for (const file of files) {
+      const filePath = file.path || file;
+      const operation = file.status === 'untracked' ? 'create_file' : 'update_existing';
+      if (
+        !(operation === 'update_existing' && matchesReviewGatedScope(filePath, context))
+        && !selectedWritableCertificates.some((certificate) => certificateCoversFile(certificate, filePath, operation))
+      ) {
+        uncertifiedWrites.push({ path: filePath, operation });
+      }
+    }
+  }
 
   const blockingReasons = [];
   if (context.mode && context.mode !== 'edit_context') {
@@ -356,6 +440,12 @@ function evaluateWritePlanStatus(files, context) {
   for (const item of referenceOnlyTouched) {
     blockingReasons.push(`${item.path} touched reference-only file ${item.reference}`);
   }
+  for (const file of unknownNewFiles) {
+    blockingReasons.push(`UNKNOWN_NEW_FILE: ${file} is not covered by selected create-capable Direct Writable scope`);
+  }
+  for (const item of uncertifiedWrites) {
+    blockingReasons.push(`UNCERTIFIED_WRITE: ${item.path} ${item.operation} is not covered by a selected writable certificate`);
+  }
   if (selectedWritableDirect.length === 0 && changedPaths.length > 0) {
     blockingReasons.push('context has no selected Direct Writable scope');
   }
@@ -365,7 +455,10 @@ function evaluateWritePlanStatus(files, context) {
     contextMode: context.mode || null,
     blockingReasons: [...new Set(blockingReasons)],
     selectedWritableDirect,
+    selectedWritableCertificates,
     referenceOnlyTouched,
+    unknownNewFiles,
+    uncertifiedWrites,
     requiredWrites: writePlan && Array.isArray(writePlan.hypotheses) ? writePlan.hypotheses : [],
     blockingWarnings,
   };