genesis-compiler 1.2.28 → 1.3.0

package/src/cli.js

@@ -9,6 +9,7 @@ import {
   getContext,
   indexCodebase,
   initialize,
+  inspectCollaboration,
   inspectEngineering,
   inspectEnvironment,
   inspectStackSection,
@@ -16,6 +17,7 @@ import {
   listEngineeringProfiles,
   listStackPieces,
   migrate,
+  setCollaboration,
   setEngineeringProfile,
   verify,
 } from './index.js';
@@ -24,11 +26,17 @@ import {
 } from './index/codex-hooks.js';
 import { engineeringProfile, readEngineeringBaseline } from './index/engineering.js';
 import { asDiagnostic, fail } from './index/errors.js';
+import {
+  HOST_CONTEXT_INPUT_ENV,
+  HOST_CONTEXT_RESOLVER_ENV,
+  SESSION_CONTEXT_INSTALLED_ENV,
+  resolveConfiguredHostContext,
+} from './index/host-context-resolver.js';
 import {
   inspectProjectFormat,
   projectFormatDiagnostic,
 } from './index/project-format.js';
-import { projectSessionContext } from './index/session-context.js';
+import { projectSessionContext, projectTurnContext } from './index/session-context.js';
 import { installedFirstPartyStackPackages } from './index/stack-catalog.js';
 import { readStack } from './index/stack.js';
 
@@ -36,6 +44,8 @@ const USAGE = `Usage:
   genesis init
   genesis adopt [product guidance...]
   genesis codex install
+  genesis collaboration show
+  genesis collaboration set <tone> <response-length> <experience> <explanation-style> [project requirements...]
   genesis engineering list
   genesis engineering show [profile]
   genesis engineering set <profile>
@@ -63,7 +73,7 @@ prompt to the agent you already use. Review all edits through the ordinary Git
 diff, then run genesis verify for the Stack's concrete checks.
 `;
 
-const COMMANDS = new Set(['adopt', 'check', 'codex', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'stack', 'verify']);
+const COMMANDS = new Set(['adopt', 'check', 'codex', 'collaboration', 'context', 'engineering', 'hook', 'index', 'init', 'inspect', 'migrate', 'prompt', 'stack', 'verify']);
 
 function parseCommand(argv) {
   if (argv.length === 0 || argv.includes('--help') || argv.includes('-h') || argv[0] === 'help') {
@@ -97,7 +107,21 @@ function parseCommand(argv) {
   if (options.task !== undefined && command !== 'prompt') {
     fail('CLI_OPTION_NOT_APPLICABLE', `Option --task is not applicable to ${command}.`);
   }
-  if (command === 'stack') {
+  if (command === 'collaboration') {
+    const [action] = operands;
+    if (!['show', 'set'].includes(action)) {
+      fail('CLI_COLLABORATION_ACTION_REQUIRED', 'Command collaboration requires show or set.');
+    }
+    if (action === 'show' && operands.length !== 1) {
+      fail('CLI_EXTRA_ARGUMENT', 'Command collaboration show accepts no extra arguments.');
+    }
+    if (action === 'set' && operands.length < 5) {
+      fail(
+        'CLI_COLLABORATION_VALUES_REQUIRED',
+        'Command collaboration set requires tone, response length, experience, and explanation style.',
+      );
+    }
+  } else if (command === 'stack') {
     if (!['list', 'add'].includes(operands[0])) {
       fail('CLI_STACK_ACTION_REQUIRED', 'Command stack requires list or add.');
     }
@@ -136,8 +160,8 @@ function parseCommand(argv) {
         'Command inspect requires environment or section <name>.',
       );
     }
-  } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session'].includes(operands[0]))) {
-    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session.');
+  } else if (command === 'hook' && (operands.length !== 1 || !['discover', 'session', 'turn'].includes(operands[0]))) {
+    fail('CLI_HOOK_ACTION_REQUIRED', 'Command hook requires exactly one of: discover, session, turn.');
   } else if (!['adopt', 'context', 'hook', 'index', 'inspect', 'prompt'].includes(command) && operands.length > 0) {
     fail('CLI_EXTRA_ARGUMENT', `Command ${command} accepts no arguments.`);
   }
@@ -159,6 +183,7 @@ function writeCheck(result) {
   const version = format.projectVersion === null ? format.status : format.projectVersion;
   line(process.stdout, `Project format: ${version} (${format.status}; CLI supports ${format.supportedVersion})`);
   line(process.stdout, `Blueprint: ${result.blueprint}`);
+  line(process.stdout, `Collaboration approach: ${result.collaboration}`);
   line(process.stdout, `Engineering approach: ${result.engineering}`);
   line(process.stdout, `Stack: ${result.stack}`);
   line(process.stdout, `Agent Skills: ${result.skills}`);
@@ -174,6 +199,21 @@ function writeCheck(result) {
   line(process.stdout, `Check: ${result.status}`);
 }
 
+function writeCollaboration(result) {
+  line(process.stdout, `Tone: ${result.tone}`);
+  line(process.stdout, `Response length: ${result.responseLength}`);
+  line(process.stdout, `Assumed experience: ${result.experience}`);
+  line(process.stdout, `Explanation style: ${result.explanationStyle}`);
+  if (result.requirements) {
+    line(process.stdout, 'Project requirements:');
+    line(process.stdout, result.requirements);
+  }
+  if (result.action === 'set') {
+    namedItems('Changed files', result.changedFiles);
+    line(process.stdout, `collaboration: ${result.status}`);
+  }
+}
+
 function writeEngineering(result) {
   if (result.action === 'list') {
     for (const profile of result.profiles) {
@@ -236,6 +276,10 @@ function writeResult(command, result) {
     writeEngineering(result);
     return;
   }
+  if (command === 'collaboration') {
+    writeCollaboration(result);
+    return;
+  }
   if (command === 'context') {
     process.stdout.write(result.context.endsWith('\n') ? result.context : `${result.context}\n`);
     return;
@@ -263,7 +307,7 @@ function writeResult(command, result) {
     return;
   }
   if (command === 'hook') {
-    if (['discover', 'session'].includes(result.kind) && result.output) line(process.stdout, result.output);
+    if (['discover', 'session', 'turn'].includes(result.kind) && result.output) line(process.stdout, result.output);
     return;
   }
   if (command === 'stack' && Array.isArray(result.pieces)) {
@@ -292,6 +336,32 @@ function writeResult(command, result) {
   line(process.stdout, `${command}: ${result.status}`);
 }
 
+async function hookSessionId(environment = process.env) {
+  if (!environment[HOST_CONTEXT_RESOLVER_ENV]) return null;
+  let source = environment[HOST_CONTEXT_INPUT_ENV];
+  if (source === undefined && !process.stdin.isTTY) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+      bytes += Buffer.byteLength(chunk);
+      if (bytes > 16 * 1024) {
+        fail('HOST_CONTEXT_INPUT_INVALID', 'The host hook input exceeds 16 KiB.');
+      }
+      chunks.push(chunk);
+    }
+    source = Buffer.concat(chunks).toString('utf8');
+  }
+  if (!String(source || '').trim()) return null;
+  let input;
+  try {
+    input = JSON.parse(source);
+  } catch {
+    fail('HOST_CONTEXT_INPUT_INVALID', 'The host hook input must contain JSON.');
+  }
+  const sessionId = input?.sessionId ?? input?.session_id;
+  return typeof sessionId === 'string' && sessionId.trim() ? sessionId.trim() : null;
+}
+
 async function cliStackPackages(projectRoot, supplied) {
   if (supplied.length > 0) return supplied;
   try {
@@ -312,6 +382,22 @@ async function execute({ command, operands, options }, { signal } = {}) {
     return adoptProject({ projectRoot, request: operands.join(' '), stackPackages });
   }
   if (command === 'codex') return installCodex();
+  if (command === 'collaboration') {
+    if (operands[0] === 'show') {
+      return { action: 'show', ...await inspectCollaboration({ projectRoot }) };
+    }
+    return {
+      action: 'set',
+      ...await setCollaboration({
+        projectRoot,
+        tone: operands[1],
+        responseLength: operands[2],
+        experience: operands[3],
+        explanationStyle: operands[4],
+        ...(operands.length > 5 ? { requirements: operands.slice(5).join(' ') } : {}),
+      }),
+    };
+  }
   if (command === 'engineering') {
     if (operands[0] === 'list') {
       return { action: 'list', status: 'ok', profiles: await listEngineeringProfiles() };
@@ -379,7 +465,38 @@ async function execute({ command, operands, options }, { signal } = {}) {
     if (operands[0] === 'discover') {
       return { kind: 'discover', ...await codexAdoptionRecommendation({ projectRoot }) };
     }
-    return { kind: 'session', ...await projectSessionContext({ projectRoot, stackPackages }) };
+    const scope = operands[0];
+    if (scope === 'session' && process.env[SESSION_CONTEXT_INSTALLED_ENV] === '1') {
+      return { kind: 'session', status: 'ready', output: '' };
+    }
+    const providerSessionId = await hookSessionId();
+    const hostContext = await resolveConfiguredHostContext({
+      projectRoot,
+      providerSessionId,
+      scope,
+    });
+    if (scope === 'turn') {
+      return hostContext === null
+        ? { kind: 'turn', status: 'ready', output: '' }
+        : {
+            kind: 'turn',
+            ...await projectTurnContext({
+              hostDriver: () => hostContext,
+              hostDriverInput: { scope: 'turn' },
+            }),
+          };
+    }
+    return {
+      kind: 'session',
+      ...await projectSessionContext({
+        ...(hostContext === null ? {} : {
+          hostDriver: () => hostContext,
+          hostDriverInput: { scope: 'session' },
+        }),
+        projectRoot,
+        stackPackages,
+      }),
+    };
   }
   if (command === 'verify') {
     return verify({

package/src/index/assets.js

@@ -3,6 +3,9 @@ import { readFile } from 'node:fs/promises';
 const root = new URL('../../', import.meta.url);
 const assets = {
   start: new URL('prompts/start.txt', root),
+  'start-new': new URL('prompts/start-new.txt', root),
+  'start-existing': new URL('prompts/start-existing.txt', root),
+  'start-existing-uninitialized': new URL('prompts/start-existing-uninitialized.txt', root),
   adopt: new URL('prompts/adopt.txt', root),
   work: new URL('prompts/work.txt', root),
   describe: new URL('prompts/describe.txt', root),

package/src/index/check.js

@@ -1,4 +1,5 @@
 import { readBlueprint } from './blueprint.js';
+import { readCollaboration } from './collaboration.js';
 import { inspectProjectSkills } from './agent-skills.js';
 import { readStack } from './stack.js';
 import { asDiagnostic } from './errors.js';
@@ -19,6 +20,7 @@ function invalidResult(area, error, projectFormat) {
     status: 'invalid',
     projectFormat,
     blueprint: area === 'blueprint' ? 'invalid' : 'valid',
+    collaboration: area === 'collaboration' ? 'invalid' : 'unknown',
     engineering: area === 'engineering' ? 'invalid' : 'unknown',
     stack: area === 'stack' ? 'invalid' : 'unknown',
     skills: area === 'skills' ? 'invalid' : 'unknown',
@@ -43,6 +45,7 @@ function formatMismatchResult(projectFormat) {
     status,
     projectFormat,
     blueprint: 'unknown',
+    collaboration: 'unknown',
     engineering: 'unknown',
     stack: 'unknown',
     skills: 'unknown',
@@ -75,7 +78,13 @@ export async function checkProject({
   }
 
   let stack;
+  let collaboration;
   let engineering;
+  try {
+    collaboration = await readCollaboration(root);
+  } catch (error) {
+    return invalidResult('collaboration', error, projectFormat);
+  }
   try {
     engineering = await readEngineering(root);
   } catch (error) {
@@ -154,6 +163,7 @@ export async function checkProject({
       : needsAttention ? 'attention' : 'ok',
     projectFormat,
     blueprint: 'valid',
+    collaboration: collaboration.status,
     engineering: engineering.status,
     stack: 'valid',
     skills: skills.status,

package/src/index/codex-hooks.js

@@ -3,13 +3,12 @@ import path from 'node:path';
 
 import { GenesisError } from './errors.js';
 import { gitContext } from './git.js';
-import { isProjectContentPath } from './paths.js';
-import { runGit } from './process.js';
-import { normalizeRelative, pathState, writeFileAtomic } from './utils.js';
+import { classifyProjectKind } from './project-files.js';
+import { pathState, writeFileAtomic } from './utils.js';
 
 const HOOKS_PATH = '.codex/hooks.json';
 const LEGACY_GENESIS_HOOKS_DESCRIPTION = 'Genesis project hooks.';
-const PROJECT_HOOK_ACTIONS = ['session', 'begin', 'stop', 'end'];
+const PROJECT_HOOK_ACTIONS = ['session', 'turn', 'begin', 'stop', 'end'];
 
 function hookCommand(action) {
   const local = `const {runCli}=await import('genesis-compiler/cli');process.exitCode=await runCli(['hook','${action}'])`;
@@ -31,6 +30,19 @@ const SESSION_HOOK = {
   },
 };
 
+const TURN_HOOK = {
+  event: 'UserPromptSubmit',
+  group: {
+    hooks: [{
+      type: 'command',
+      command: hookCommand('turn'),
+      commandWindows: 'genesis hook turn',
+      timeout: 5,
+      additionalContextLimit: 512,
+    }],
+  },
+};
+
 const OBSOLETE_PROJECT_HOOK_COMMANDS = new Set(PROJECT_HOOK_ACTIONS.flatMap((action) => [
   hookCommand(action),
   `genesis hook ${action}`,
@@ -84,26 +96,23 @@ export async function installCodexHooks({ projectRoot } = {}) {
   removeGenesisProjectHooks(value.hooks);
   const groups = value.hooks[SESSION_HOOK.event] ||= [];
   groups.push(SESSION_HOOK.group);
+  const turnGroups = value.hooks[TURN_HOOK.event] ||= [];
+  turnGroups.push(TURN_HOOK.group);
   const rendered = `${JSON.stringify(value, null, 2)}\n`;
   if (source === rendered) return { status: 'unchanged', changedFiles: [] };
   await writeFileAtomic(location, rendered);
   return { status: 'updated', changedFiles: [HOOKS_PATH] };
 }
 
-function zeroPaths(buffer) {
-  return [...new Set(buffer.toString('utf8').split('\0').map(normalizeRelative).filter(Boolean))];
-}
-
 export async function codexAdoptionRecommendation({ projectRoot = process.cwd() } = {}) {
   let root;
   try { root = (await gitContext(projectRoot)).repositoryRoot; } catch { return { status: 'not-applicable', output: '' }; }
   if ((await pathState(path.join(root, 'genesis/blueprint.md'))).exists) {
     return { status: 'not-applicable', output: '' };
   }
-  const files = zeroPaths((await runGit(root, [
-    'ls-files', '-z', '--cached', '--others', '--exclude-standard',
-  ])).stdout).filter(isProjectContentPath);
-  if (files.length === 0) return { status: 'not-applicable', output: '' };
+  if (await classifyProjectKind({ projectRoot: root }) === 'new') {
+    return { status: 'not-applicable', output: '' };
+  }
   return {
     status: 'ready',
     output: [