rig-create 0.0.0-stage → 1.0.0

package/src/job-runtime.ts

@@ -0,0 +1,99 @@
+/** Private stdin transport for synchronous writers. Capabilities never enter argv. */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { askOutcomeLines, assertRequestedDraft, assertRequestedRig, closeCreateJob, listCreateJobActs, openCreateJob, openDraftPublication, openRecordPublication, requestedRecordResult, publishPending, reconcileCreateJob, refuseAskOutcomes, type AskOutcome } from './job-host.ts';
+import { failPublication, pendingPublications, reconcilePublication } from './job-outbox.ts';
+import { jobActsText } from './job-acts.ts';
+import { Refusal, refuse } from './refusal.ts';
+
+async function run(): Promise<void> {
+  const input = JSON.parse(readFileSync(0, 'utf8')) as { root: string; id?: string; reviewer?: string; role?: 'owner' | 'delegate'; draft?: string; rig?: string; question?: string; plan?: boolean; now: number; json?: boolean };
+  const root = resolve(input.root);
+  switch (process.argv[2]) {
+    case 'publish': {
+      const entry = pendingPublications(root).find(entry => entry.id === input.id);
+      if (!entry) refuse('JOB_OUTBOX_INVALID', 'project.json: pending writer receipt is absent; restore the private outbox');
+      let outcomes: AskOutcome[] = [];
+      try { await reconcilePublication(root, entry, async item => { outcomes = await publishPending(item); }); }
+      catch (error) {
+        const failure = error instanceof Refusal ? { code: error.code, message: error.message }
+          : { code: 'JOB_PUBLISH_PENDING', message: 'project.json: host publication failed; restore the bound host before rig-create job reconcile' };
+        failPublication(root, entry, failure);
+        throw new Refusal('JOB_PUBLISH_PENDING', 'project.json: committed publication is pending; run rig-create job reconcile');
+      }
+      const lines = askOutcomeLines(outcomes);
+      if (lines.length) console.log(lines.join('\n'));
+      refuseAskOutcomes(outcomes);
+      break;
+    }
+    case 'acts': {
+      const result = await listCreateJobActs(root);
+      console.log(input.json ? JSON.stringify(result) : jobActsText(result));
+      break;
+    }
+    case 'reconcile': console.log(`job: reconciled ${await reconcileCreateJob(root)} publication(s)`); break;
+    case 'close': await closeCreateJob(root); console.log('job: closed'); break;
+    case 'open': {
+      if (!input.reviewer || !input.role) refuse('JOB_BINDING_INVALID', 'project.json: job open needs --reviewer and --role owner|delegate');
+      requestedRecordResult(root, input.question, input.plan, input.now);
+      assertRequestedRig(root, input.rig, input.draft);
+      assertRequestedDraft(root, input.draft);
+      let stopping = false;
+      let stopHost: (() => void) | null = null;
+      const onSignal = () => {
+        stopping = true;
+        stopHost?.();
+      };
+      process.on('SIGINT', onSignal);
+      process.on('SIGTERM', onSignal);
+      const host = await openCreateJob(root, { id: input.reviewer, role: input.role }, input.now, undefined, input.question !== undefined || input.plan);
+      if (stopping) {
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+        host.stop();
+        break;
+      }
+      console.log(host.ownerUrl);
+      // The page shows the record's current draft and its asks. A refused publish or ask is
+      // named here; a foreground host keeps serving so `job reconcile` and `job open` can retry.
+      try { console.log((await (input.question !== undefined || input.plan ? openRecordPublication(root, host, input.question, Boolean(input.plan), input.now) : openDraftPublication(root, host, input.now, input.draft, input.rig))).join('\n')); }
+      catch (error) {
+        if (host.reused) {
+          process.off('SIGINT', onSignal);
+          process.off('SIGTERM', onSignal);
+          host.stop();
+          throw error;
+        }
+        console.error(error instanceof Refusal ? `${error.code}: ${error.message}` : 'JOB_PUBLISH_PENDING: project.json: draft publication failed; run rig-create job reconcile');
+        process.exitCode = 1;
+      }
+      if (host.reused || stopping) {
+        process.off('SIGINT', onSignal);
+        process.off('SIGTERM', onSignal);
+        host.stop();
+      } else {
+        const timer = setInterval(() => {
+          if (host.session.status().status === 'closed') stopHost?.();
+        }, 1000);
+        stopHost = () => {
+          clearInterval(timer);
+          process.off('SIGINT', onSignal);
+          process.off('SIGTERM', onSignal);
+          host.stop();
+          process.exit(process.exitCode ?? 0);
+        };
+      }
+      break;
+    }
+    default: refuse('JOB_BINDING_INVALID', 'project.json: use rig-create job open|acts|reconcile|close');
+  }
+}
+
+if (import.meta.main) {
+  try { await run(); }
+  catch (error) {
+    // Unexpected errors may embed producer input. Only controlled refusals leave this process.
+    console.error(error instanceof Refusal ? `${error.code}: ${error.message}` : 'JOB_PUBLISH_PENDING: project.json: publication operation failed; run rig-create job reconcile');
+    process.exitCode = 1;
+  }
+}

package/src/job-writer.ts

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync } from './check-reads.ts';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { acquireJobLock, enqueuePublication, failPublication, jobPrivateRoot, pendingPublications, readWriterBinding, type PendingPublication } from './job-outbox.ts';
+import { liveManifestPath, draftPublicationContext, prepareDraftManifest, prepareLiveManifest, publicationSelector } from './job-publication.ts';
+import type { Finding } from './check.ts';
+import { refuse } from './refusal.ts';
+import type { JsonObject } from './templates.ts';
+
+export function acquireBoundJobWrite(root: string): () => void {
+  if (!readWriterBinding(root)) return () => {};
+  const release = acquireJobLock(root)!;
+  try {
+    if (pendingPublications(root, true).length) refuse('JOB_PUBLISH_PENDING', 'project.json: an earlier committed publication is pending; run rig-create job reconcile before another bound write');
+  } catch (error) { release(); throw error; }
+  return release;
+}
+
+export function prepareVersionIntent(root: string, bytes: Buffer, n: number): PendingPublication | null {
+  const binding = readWriterBinding(root);
+  if (!binding) return null;
+  const project = JSON.parse(bytes.toString('utf8')) as JsonObject;
+  return enqueuePublication(root, binding, { path: liveManifestPath(root, project, n), selector: publicationSelector(project, n) }, bytes);
+}
+
+export const SOURCE_CONDITION = '@rig-c/source';
+export const SOURCE_CONDITION_FLAG = `--conditions=${SOURCE_CONDITION}`;
+
+const EXEC_ARGV_VALUE_FLAGS = new Set([
+  '-e', '--eval', '-p', '--print', '-r', '--preload', '--import',
+  '--config', '-c', '--cwd', '--env-file', '--define', '-d', '--loader', '-l',
+]);
+
+/** Forward only the explicit `@rig-c/source` condition to job-runtime child launches; never arbitrary `process.execArgv` flags. */
+export function jobRuntimeExecArgv(execArgv: readonly string[] = process.execArgv): string[] {
+  for (let i = 0; i < execArgv.length; i++) {
+    const arg = execArgv[i];
+    if (arg === '--') break;
+    if (arg === SOURCE_CONDITION_FLAG) return [SOURCE_CONDITION_FLAG];
+    if (arg === '--conditions') {
+      if (execArgv[++i] === SOURCE_CONDITION) return [SOURCE_CONDITION_FLAG];
+      continue;
+    }
+    if (arg !== undefined && EXEC_ARGV_VALUE_FLAGS.has(arg)) i++;
+  }
+  return [];
+}
+
+export function jobRuntimeCommand(
+  action: string,
+  runtime = fileURLToPath(new URL('./job-runtime.ts', import.meta.url)),
+  execArgv: readonly string[] = process.execArgv,
+): string[] {
+  return [process.execPath, ...jobRuntimeExecArgv(execArgv), runtime, action];
+}
+
+const publishedLines: string[] = [];
+
+export function takePublishedLines(): string[] {
+  return publishedLines.splice(0);
+}
+
+/** Called by the committing writer, before its own locks are released. */
+export function publishCommittedVersion(root: string, n: number | string): string[] {
+  const binding = readWriterBinding(root);
+  if (!binding) return [];
+  const project = JSON.parse(readFileSync(join(root, 'project.json'), 'utf8')) as JsonObject;
+  if (typeof n === 'string') {
+    const warnings: Finding[] = [];
+    draftPublicationContext(root, project, n, warnings);
+    publishedLines.push(...warnings.map(finding => `WARN ${finding.code}: ${finding.message}`));
+  }
+  const result = typeof n === 'string' ? draftPublicationResult(n) : { path: liveManifestPath(root, project, n), selector: publicationSelector(project, n) };
+  const entry = enqueuePublication(root, binding, result);
+  entry.phase = 'pending';
+  failPublication(root, entry, entry.failure);
+  try {
+    if (typeof n === 'string') prepareDraftManifest(root, project, n);
+    else {
+      const warnings: Finding[] = [];
+      prepareLiveManifest(root, project, n, warnings);
+      publishedLines.push(...warnings.map(finding => `WARN ${finding.code}: ${finding.message}`));
+    }
+  } catch {
+    const failure = { code: 'JOB_PUBLICATION_INVALID', message: 'project.json: retained review package cannot be prepared; restore its model/direction sources' };
+    failPublication(root, entry, failure);
+    refuse('JOB_PUBLISH_PENDING', `project.json: committed record ${entry.recordHash} is pending (${failure.code}); run rig-create job reconcile`);
+  }
+  // A separate Bun process runs asynchronous Review while this synchronous writer
+  // keeps its existing call contract and retains both write locks.
+  let child: ReturnType<typeof Bun.spawnSync<'pipe', 'pipe'>>;
+  try {
+    child = Bun.spawnSync(jobRuntimeCommand('publish'), {
+      stdin: Buffer.from(JSON.stringify({ root, id: entry.id })), stdout: 'pipe', stderr: 'pipe',
+    });
+  } catch {
+    refuse('JOB_PUBLISH_PENDING', `project.json: record ${entry.recordHash} committed but the publication process could not start; restore the runtime and run rig-create job reconcile`);
+  }
+  const lines = child.stdout.toString('utf8').split('\n').map(line => line.trim()).filter(Boolean);
+  publishedLines.push(...lines);
+  if (child.exitCode !== 0) {
+    const path = join(jobPrivateRoot(root), 'outbox', `${entry.id}.json`);
+    if (!existsSync(path)) {
+      const match = /^([A-Z][A-Z0-9_]*): ([\s\S]+)$/.exec(child.stderr.toString('utf8').trim());
+      if (match) refuse(match[1]!, match[2]!);
+      return lines; // The child acknowledged before its abnormal exit.
+    }
+    const pending = JSON.parse(readFileSync(path, 'utf8')) as PendingPublication;
+    refuse('JOB_PUBLISH_PENDING', `project.json: committed record ${entry.recordHash} awaits publication${pending.failure ? ` (${pending.failure.code}: ${pending.failure.message})` : ''}; run rig-create job reconcile`);
+  }
+  return lines;
+}
+
+export function draftPublicationResult(id: string): { path: string; selector: { kind: 'draft'; id: string } } {
+  return { path: `review-draft-${id}.json`, selector: { kind: 'draft', id } };
+}
+
+export function prepareDraftIntent(root: string, bytes: Buffer, id: string): PendingPublication | null {
+  const binding = readWriterBinding(root);
+  if (!binding) return null;
+  draftPublicationContext(root, JSON.parse(bytes.toString('utf8')) as JsonObject, id);
+  return enqueuePublication(root, binding, draftPublicationResult(id), bytes);
+}

package/src/meshes-bust.ts

@@ -0,0 +1,63 @@
+/**
+ * The bust at `meshes` (docs/CRAFT.md M2, docs/CHECKS.md § The bust at meshes):
+ * the bust is meshed with its own regions by default, and the interview asks
+ * only whether to leave it out. The `x_deform` value records that as
+ * `bust: "default"` or `bust: { "excluded": true, "reason": "<non-empty>" }`;
+ * an absent `bust` is the default. An exclusion without a reason is refused,
+ * since the agent passes it to parts as the opt-out (rig-c/parts#986) and a
+ * reason nobody wrote cannot be reviewed.
+ *
+ * Read on the `meshes` guide's value, the agent's decision on a delegation, and
+ * every `additions[].value`, since a later sentence can carry the exclusion.
+ * A value that is not an object is not read: free-text values predate this shape.
+ */
+import { asArray, isObject, itemFor, type Ctx } from './check.ts';
+import type { Json } from './templates.ts';
+
+/** The waypoint whose guide carries the `x_deform` value. */
+export const MESHES_WAYPOINT = 'meshes';
+
+/** The one value of `bust` that is not an exclusion. */
+export const BUST_DEFAULT = 'default';
+
+function valuesOf(ctx: Ctx): { value: Json | undefined; path: string }[] {
+  const item = itemFor(ctx, MESHES_WAYPOINT);
+  if (item === undefined) return [];
+  const s = item.state;
+  const out: { value: Json | undefined; path: string }[] = [];
+  if (s.state === 'user') out.push({ value: s.answer.value, path: `${item.path}.value` });
+  else if (s.state !== 'delegated') return [];
+  // A user sentence that left part open carries the agent's choice beside it
+  // (docs/INTERVIEW.md), so the decision is read on both states.
+  if (isObject(s.answer.agent_decision)) {
+    out.push({ value: s.answer.agent_decision.value, path: `${item.path}.agent_decision.value` });
+  }
+  asArray(s.answer.additions).forEach((add, i) => {
+    if (isObject(add)) out.push({ value: add.value, path: `${item.path}.additions[${i}].value` });
+  });
+  return out;
+}
+
+/** Refuses a `bust` that is neither the default nor an exclusion with a non-empty reason. */
+export function checkMeshesBust(ctx: Ctx): void {
+  for (const { value, path } of valuesOf(ctx)) {
+    if (!isObject(value) || !('bust' in value)) continue;
+    const bust = value.bust;
+    const at = `${path}.bust`;
+    if (bust === BUST_DEFAULT) continue;
+    if (isObject(bust) && bust.excluded === true) {
+      if (typeof bust.reason === 'string' && bust.reason.trim() !== '') continue;
+      ctx.refusals.push({
+        code: 'BUST_EXCLUSION_UNREASONED',
+        path: at,
+        message: `${at}: the bust is excluded with no reason; write the user's reason (a rigid breastplate, say) in \`reason\`, or record the default ("${BUST_DEFAULT}")`,
+      });
+      continue;
+    }
+    ctx.refusals.push({
+      code: 'BUST_VALUE_UNKNOWN',
+      path: at,
+      message: `${at}: ${JSON.stringify(bust ?? null)} is neither "${BUST_DEFAULT}" nor { "excluded": true, "reason": "…" }`,
+    });
+  }
+}