/**
 * The recurrence gate for module-orchestrator-primitives slice 7
 * (tasks.md 7.1): exactly ONE hook dispatch path.
 *
 * A module-declared hook is anything a manifest declares under `hooks:`.
 * Since slice 7, every such hook — including `on_upstream_publish` — is
 * executed by the ordinary executor (`apps/celilo/src/hooks/executor.ts`
 * → `hook-runner.ts`, jailed). No other celilo service may spawn a
 * process to run one. That second path is how `bash <script>` with the
 * whole of celilo's `process.env` reached a module-supplied script
 * (design D6).
 *
 * The scan asserts on the DISPATCH, not on an interpreter name: it flags
 * any file that (a) reaches a child process AND (b) consumes what a
 * module declares under `hooks:`. Asserting on the literal `bash` would
 * pass the moment someone renamed the interpreter, and would miss a
 * second path built on `sh`, `bun run` or a direct `Bun.spawn`.
 *
 * `apps/celilo/src/hooks/**` is the one sanctioned path and is exempt:
 * `executor.ts` and `hook-runner.ts` are where module-declared hooks are
 * supposed to be spawned, jailed. Every other service file that both
 * spawns and reads hook declarations is a second dispatch path.
 *
 * Seen-fail note (Rule 7.6): this scan was written RED against
 * `hook-dispatch.ts` at the spawn it then contained, and re-proven RED in
 * task 7.5 by restoring that spawn in a scratch copy of the tree.
 */

import { describe, expect, test } from 'bun:test';
import { readFileSync, readdirSync, statSync } from 'node:fs';
import { join } from 'node:path';

const SRC_ROOT = join(__dirname, '..', '..');

/** Directories that ARE the one hook dispatch path. Spawning there is the design. */
const EXEMPT_DIRS = new Set(['hooks']);

/**
 * (a) The file reaches a child process. Covers `node:child_process` in
 * every spelling plus Bun's own spawner.
 */
const CHILD_PROCESS_REACH = /node:child_process|Bun\.spawn/;

/**
 * (b) The file consumes a hook's declared SCRIPT for dispatch — the input
 * side of a hook execution. Deliberately narrow: a service that merely
 * PEEKS at the manifest hooks block to gate a framework call (e.g.
 * `system update` reading `hooks?.on_backup` to skip a backup) reads hook
 * declarations without dispatching one, and stays out of scope. Comment
 * mentions are stripped before matching: a docblock naming the hook this
 * gate replaced is prose, not a dispatch.
 */
const HOOK_DISPATCH_MARKERS = ['UpstreamHookEntry', 'planHookDispatch', 'hook.script'];

/**
 * Strip line and block comments so a prose mention of a marker does not
 * flag a file. Conservative on purpose: strings containing `//` (URLs) can
 * lose a tail, which is safe here — it can only REMOVE a match, and a
 * string carrying a hook-dispatch marker is not itself a dispatch.
 */
function stripComments(src: string): string {
  return src.replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/^\s*\/\/.*$/gm, ' ');
}

function listTsFiles(dir: string, out: string[] = []): string[] {
  for (const entry of readdirSync(dir)) {
    const full = join(dir, entry);
    if (statSync(full).isDirectory()) {
      if (EXEMPT_DIRS.has(entry)) continue;
      listTsFiles(full, out);
    } else if (entry.endsWith('.ts') && !entry.endsWith('.test.ts')) {
      out.push(full);
    }
  }
  return out;
}

describe('exactly one hook dispatch path (module-orchestrator-primitives 7.1)', () => {
  test('no service outside apps/celilo/src/hooks spawns a process for a module-declared hook', () => {
    const violations: string[] = [];
    for (const file of listTsFiles(SRC_ROOT)) {
      const src = stripComments(readFileSync(file, 'utf-8'));
      if (!CHILD_PROCESS_REACH.test(src)) continue;
      if (!HOOK_DISPATCH_MARKERS.some((m) => src.includes(m))) continue;
      violations.push(file.replace(`${SRC_ROOT}/`, ''));
    }
    expect(violations).toEqual([]);
  });

  test('the one sanctioned path still exists (executor.ts)', () => {
    const executor = readFileSync(join(SRC_ROOT, 'hooks', 'executor.ts'), 'utf-8');
    expect(executor).toContain('export async function invokeHook');
    expect(executor).toContain('export async function executeHookScript');
  });
});