@orchestrator-claude/definitions 3.32.2 → 3.34.0

package/hooks/post-implement.mjs

@@ -0,0 +1,238 @@
+import { createRequire as __createRequireShim } from 'node:module'; const require = __createRequireShim(import.meta.url);
+
+// hooks/lib/api-client.ts
+import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../project-root-resolver/dist/index.js
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+function resolveProjectRoot(cwd, sentinel = ".orchestrator") {
+  let currentDir = cwd;
+  for (; ; ) {
+    if (existsSync(join(currentDir, sentinel))) {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// hooks/lib/api-client.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var PROJECT_ROOT = join2(__dirname, "..", "..", "..");
+var STATE_DIR = join2(PROJECT_ROOT, ".orchestrator", ".state");
+var JWT_CACHE = join2(STATE_DIR, "jwt-token");
+var DEBUG_LOG = join2(STATE_DIR, "hook-debug.log");
+mkdirSync(STATE_DIR, { recursive: true });
+var API_URL = process.env.ORCHESTRATOR_API_URL || "http://localhost:3001";
+var AUTH_EMAIL = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || "system@orchestrator.local";
+var AUTH_PASSWORD = process.env.ORCHESTRATOR_ADMIN_PASSWORD || process.env.ORCHESTRATOR_AUTH_PASSWORD || "system123";
+var PROJECT_ID = process.env.ORCHESTRATOR_PROJECT_ID || "";
+function resolveHookProjectRoot(cwd) {
+  return resolveProjectRoot(cwd);
+}
+var projectIdResolutionAttempted = false;
+async function ensureProjectIdResolved(token) {
+  if (PROJECT_ID || projectIdResolutionAttempted) return;
+  projectIdResolutionAttempted = true;
+  try {
+    const rootPath = resolveHookProjectRoot(process.cwd());
+    if (rootPath === null) {
+      log(
+        "API-CLIENT",
+        "ensureProjectIdResolved: cwd not registered (.orchestrator sentinel not found) \u2014 skipping"
+      );
+      return;
+    }
+    const resolved = await resolveProjectIdByPath(rootPath, token);
+    if (resolved) {
+      PROJECT_ID = resolved;
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: resolved projectId=${resolved} rootPath=${rootPath}`
+      );
+    } else {
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: rootPath=${rootPath} not registered to any project \u2014 skipping`
+      );
+    }
+  } catch (err) {
+    log(
+      "API-CLIENT",
+      `ensureProjectIdResolved: unexpected failure \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function log(prefix, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
+  try {
+    const line = `[${ts}] ${prefix}: ${msg}
+`;
+    writeFileSync(DEBUG_LOG, line, { flag: "a" });
+  } catch {
+  }
+}
+function getCachedToken() {
+  try {
+    const stat = statSync(JWT_CACHE);
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs < 35e5) {
+      return readFileSync(JWT_CACHE, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+async function login() {
+  try {
+    const resp = await fetch(`${API_URL}/api/v1/auth/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Project-ID": PROJECT_ID
+      },
+      body: JSON.stringify({ email: AUTH_EMAIL, password: AUTH_PASSWORD }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const token = data.accessToken || data.data?.accessToken || "";
+    if (token) {
+      writeFileSync(JWT_CACHE, token);
+    }
+    return token || null;
+  } catch {
+    return null;
+  }
+}
+async function getToken() {
+  const token = getCachedToken() || await login();
+  if (token) {
+    await ensureProjectIdResolved(token);
+  }
+  return token;
+}
+async function apiGet(path, token, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(`${API_URL}${path}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "X-Project-ID": PROJECT_ID
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function resolveProjectIdByPath(rootPath, token) {
+  const resp = await apiGet(
+    `/api/v1/projects/resolve?rootPath=${encodeURIComponent(rootPath)}`,
+    token
+  );
+  return resp?.projectId ?? null;
+}
+async function getActiveWorkflow() {
+  const token = await getToken();
+  if (!token) return null;
+  for (const status of ["in_progress", "awaiting_agent", "awaiting_approval"]) {
+    const resp = await apiGet(
+      `/api/v1/workflows?status=${status}&limit=1`,
+      token,
+      3e3
+    );
+    const list = resp?.data || (Array.isArray(resp) ? resp : null);
+    const wf = list?.[0];
+    if (wf?.id) return wf;
+  }
+  return null;
+}
+async function getWorkflowStatus(workflowId) {
+  const token = await getToken();
+  if (!token) return null;
+  return apiGet(`/api/v1/workflows/${workflowId}/status`, token);
+}
+var LAST_COMPLETED_FILE = join2(STATE_DIR, "last-completed-workflow.json");
+var LAST_COMPLETED_TTL_MS = 60 * 60 * 1e3;
+var INVOCATIONS_DIR = join2(STATE_DIR, "invocations");
+var INVOCATION_STATE_TTL_MS = 4 * 60 * 60 * 1e3;
+var DISPATCH_INTENT_DIR = join2(STATE_DIR, "dispatch-intent");
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current != null ? String(current) : "";
+}
+function outputContext(hookEvent, context) {
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: hookEvent,
+        additionalContext: context
+      }
+    })
+  );
+}
+
+// hooks/post-implement.ts
+var HOOK = "POST-IMPLEMENT";
+var POST_IMPLEMENT_PHASE = "review";
+function isImplementCompleted(currentPhase) {
+  return (currentPhase ?? "").toLowerCase() === POST_IMPLEMENT_PHASE;
+}
+function buildPostImplementSignal(workflowId) {
+  return [
+    `[ORCHESTRATOR] IMPLEMENT completed for ${workflowId} \u2014 dispatch the docs-guardian sub-agent before proceeding past the IMPLEMENT gate.`,
+    `(RFC-034 System-A post-implement signal: docs-guardian checks documentation compliance against the DOCS-CONSTITUTION after implementation.)`
+  ].join("\n");
+}
+async function main() {
+  const stdin = await readStdin();
+  const toolName = getField(stdin, "tool_name") || getField(stdin, "tool");
+  if (toolName && !toolName.includes("advancePhase")) {
+    return;
+  }
+  const wfId = getField(stdin, "tool_input.workflowId") || (await getActiveWorkflow())?.id || "";
+  if (!wfId) {
+    log(HOOK, "no workflow id resolvable \u2014 skip (fail-open)");
+    return;
+  }
+  const status = await getWorkflowStatus(wfId);
+  if (!status) {
+    log(HOOK, `no status for workflow ${wfId} \u2014 skip (fail-open)`);
+    return;
+  }
+  const phase = (status.currentPhase || "").toLowerCase();
+  log(HOOK, `workflow=${wfId} post-advance currentPhase=${phase}`);
+  if (!isImplementCompleted(phase)) {
+    return;
+  }
+  log(HOOK, `IMPLEMENT completed for ${wfId} \u2014 emitting docs-guardian dispatch signal`);
+  outputContext("PostToolUse", buildPostImplementSignal(wfId));
+}
+main().catch(() => process.exit(0));