328 lines
17 KiB
TypeScript
328 lines
17 KiB
TypeScript
import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
|
|
import { join } from "node:path";
|
|
import {
|
|
addBlocker,
|
|
bumpPatchVersion,
|
|
gotoStage,
|
|
passStage,
|
|
recordEvidence,
|
|
resolveBlocker,
|
|
startStage,
|
|
summarizeState,
|
|
} from "./state";
|
|
import { stage, type ArtifactRecord, type PomState, type ValidationScope } from "./domain";
|
|
import {
|
|
appendMarkdownLog,
|
|
recordHiveEvent,
|
|
registerArtifact,
|
|
syncKnowledgeBase,
|
|
writeHiveMission,
|
|
} from "./persistence";
|
|
import { validatePom } from "./validators";
|
|
import { getPrompt, listPrompts, renderStagePrompt } from "./prompts";
|
|
import { buildHiveMission, missionToTaskBatch } from "./studio";
|
|
import { exportProject } from "./exporter";
|
|
import { loadPomConfig } from "./config";
|
|
import { routeStage } from "./router";
|
|
import { checkpointStage, enterStageBranch } from "./git";
|
|
import { toolCallComponent, toolResultComponent, type PomTheme } from "./visual";
|
|
import type { PomRuntime } from "./runtime";
|
|
import { updateChrome } from "./ui";
|
|
|
|
function visual(runtime: PomRuntime, label: string) {
|
|
return {
|
|
renderCall(args: Record<string, unknown>, options: { spinnerFrame?: number }, theme: PomTheme) {
|
|
const action = [args.action, args.op, args.scope, args.kind, args.path].find((value) => typeof value === "string") as string | undefined;
|
|
return toolCallComponent(label, action, theme, runtime.get().motion, options.spinnerFrame);
|
|
},
|
|
renderResult(
|
|
result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
|
|
options: { expanded: boolean; isPartial: boolean },
|
|
theme: PomTheme,
|
|
) {
|
|
return toolResultComponent(result, options.expanded, options.isPartial, theme, runtime.get().view);
|
|
},
|
|
};
|
|
}
|
|
|
|
function textResult(text: string, details?: unknown, isError = false) {
|
|
return { content: [{ type: "text" as const, text }], details, isError };
|
|
}
|
|
|
|
async function refresh(_pi: ExtensionAPI, runtime: PomRuntime, ctx: ExtensionContext): Promise<void> {
|
|
const state = runtime.get();
|
|
const config = await loadPomConfig(state.projectRoot);
|
|
updateChrome(ctx, state, config, runtime);
|
|
}
|
|
|
|
export function registerPomTools(pi: ExtensionAPI, runtime: PomRuntime): void {
|
|
const { z } = pi.zod;
|
|
|
|
// @ts-expect-error OMP 16.4.x + Zod v4 can exceed TypeScript instantiation depth while contextualizing this complete tool schema.
|
|
pi.registerTool({
|
|
...visual(runtime, "State"),
|
|
name: "pom_state",
|
|
label: "POM State",
|
|
description: "Read or update canonical POM configuration, decisions, assumptions, and warnings.",
|
|
defaultInactive: true,
|
|
approval: "write",
|
|
parameters: z.object({
|
|
action: z.enum(["get", "configure", "decision", "assumption", "warning"]),
|
|
value: z.string().optional(),
|
|
mode: z.enum(["autopilot", "collaborative", "strict-autopilot"]).optional(),
|
|
view: z.enum(["cinematic", "rich", "compact", "minimal"]).optional(),
|
|
motion: z.enum(["off", "subtle", "full"]).optional(),
|
|
}),
|
|
async execute(_id, params, signal, _onUpdate, ctx) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
const state = structuredClone(runtime.get());
|
|
if (params.action === "configure") {
|
|
state.mode = params.mode ?? state.mode;
|
|
state.view = params.view ?? state.view;
|
|
state.motion = params.motion ?? state.motion;
|
|
}
|
|
if (params.action === "decision" && params.value?.trim() && !state.decisions.includes(params.value.trim())) state.decisions.push(params.value.trim());
|
|
if (params.action === "assumption" && params.value?.trim() && !state.assumptions.includes(params.value.trim())) state.assumptions.push(params.value.trim());
|
|
if (params.action === "warning" && params.value?.trim() && !state.warnings.includes(params.value.trim())) state.warnings.push(params.value.trim());
|
|
if (params.action !== "get") await runtime.set(state);
|
|
await refresh(pi, runtime, ctx);
|
|
return textResult(summarizeState(runtime.get()), runtime.get());
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Stage"),
|
|
name: "pom_stage",
|
|
label: "POM Stage",
|
|
description: "Start, inspect, evidence, block, resolve, pass, or navigate the authoritative stage machine.",
|
|
defaultInactive: true,
|
|
approval: "write",
|
|
parameters: z.object({
|
|
action: z.enum(["inspect", "start", "evidence", "block", "resolve", "pass", "goto"]),
|
|
stage: z.number().int().min(0).max(8).optional(),
|
|
criterionId: z.string().optional(),
|
|
summary: z.string().optional(),
|
|
paths: z.array(z.string()).optional(),
|
|
agent: z.string().optional(),
|
|
reason: z.string().optional(),
|
|
owner: z.string().optional(),
|
|
blockerId: z.string().optional(),
|
|
resolution: z.string().optional(),
|
|
allStages: z.boolean().optional(),
|
|
validationScope: z.enum(["quick", "stage", "canon", "continuity", "knowledge", "files", "delivery", "all"]).optional(),
|
|
}),
|
|
async execute(_id, params, signal, onUpdate, ctx) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
let state = runtime.get();
|
|
if (params.action === "start") {
|
|
state = startStage(state, params.stage ?? state.currentStage, params.allStages ?? false);
|
|
await runtime.set(state);
|
|
const config = await loadPomConfig(state.projectRoot);
|
|
await enterStageBranch(state, config);
|
|
await routeStage(pi, ctx, state);
|
|
} else if (params.action === "goto") {
|
|
if (params.stage === undefined) throw new Error("stage is required");
|
|
state = gotoStage(state, params.stage);
|
|
await runtime.set(state);
|
|
} else if (params.action === "evidence") {
|
|
if (!params.criterionId || !params.summary) throw new Error("criterionId and summary are required");
|
|
state = recordEvidence(state, params.criterionId, params.summary, params.paths ?? [], params.agent);
|
|
await runtime.set(state);
|
|
} else if (params.action === "block") {
|
|
state = addBlocker(state, params.reason ?? "Unspecified blocker", params.owner);
|
|
await runtime.set(state);
|
|
} else if (params.action === "resolve") {
|
|
if (!params.blockerId) throw new Error("blockerId is required");
|
|
state = resolveBlocker(state, params.blockerId, params.resolution ?? "Resolved");
|
|
await runtime.set(state);
|
|
} else if (params.action === "pass") {
|
|
onUpdate?.({ content: [{ type: "text", text: "Running deterministic stage gate…" }] });
|
|
const wasAllStages = state.activeRun?.allStages ?? false;
|
|
const scope = (params.validationScope ?? (state.currentStage === 8 ? "delivery" : "stage")) as ValidationScope;
|
|
const report = await validatePom(state, scope);
|
|
runtime.telemetry.validationFailures = report.checks.filter((item) => item.status === "fail").length;
|
|
pi.sendMessage({ customType: "pom:validation", content: `${report.passed ? "PASS" : "FAIL"} ${scope}`, display: true, details: report }, { triggerTurn: false });
|
|
if (!report.passed || !report.reportPath) return textResult(`Stage gate FAIL · ${runtime.telemetry.validationFailures} failures`, report, true);
|
|
const passedStage = state.currentStage;
|
|
state = passStage(state, report.reportPath);
|
|
await runtime.set(state);
|
|
const config = await loadPomConfig(state.projectRoot);
|
|
const commit = await checkpointStage(state, config, `pom: complete stage ${passedStage} ${stage(passedStage).slug}`);
|
|
pi.sendMessage({ customType: "pom:milestone", content: `Stage ${passedStage} complete`, display: true, details: { stage: passedStage, status: "PASS", path: report.reportPath, commit } }, { triggerTurn: false });
|
|
if (wasAllStages && passedStage < 8) {
|
|
state = startStage(state, state.currentStage, true);
|
|
await runtime.set(state);
|
|
await enterStageBranch(state, config);
|
|
await routeStage(pi, ctx, state);
|
|
pi.sendUserMessage(await renderStagePrompt(state, true), { deliverAs: "followUp" });
|
|
}
|
|
}
|
|
await syncKnowledgeBase(runtime.get());
|
|
await refresh(pi, runtime, ctx);
|
|
return textResult(summarizeState(runtime.get()), runtime.get());
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Artifact"),
|
|
name: "pom_artifact",
|
|
label: "POM Artifact",
|
|
description: "Register a non-empty canonical artifact with measured size, SHA-256, status, source, and rights metadata.",
|
|
defaultInactive: true,
|
|
approval: "write",
|
|
parameters: z.object({
|
|
path: z.string(),
|
|
category: z.string().default("other"),
|
|
status: z.enum(["draft", "reviewed", "approved", "superseded"]).default("draft"),
|
|
rightsStatus: z.enum(["original", "licensed", "public-domain", "reference-only", "unknown"]).default("unknown"),
|
|
source: z.string().optional(),
|
|
notes: z.string().optional(),
|
|
}),
|
|
async execute(_id, params, signal) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
const state = runtime.get();
|
|
const artifactVersion = bumpPatchVersion(state.artifactVersion);
|
|
const record = await registerArtifact(state, params.path, {
|
|
category: params.category,
|
|
status: params.status as ArtifactRecord["status"],
|
|
rightsStatus: params.rightsStatus as ArtifactRecord["rightsStatus"],
|
|
source: params.source,
|
|
notes: params.notes,
|
|
version: artifactVersion,
|
|
});
|
|
const next = structuredClone(state);
|
|
next.artifactVersion = artifactVersion;
|
|
if (/canon|bible|continuity|timeline|world|character/i.test(params.category)) {
|
|
next.canonVersion = bumpPatchVersion(next.canonVersion);
|
|
}
|
|
await runtime.set(next);
|
|
return textResult(`Registered ${record.path} · v${record.version} · ${record.bytes} bytes · ${record.sha256.slice(0, 12)}`, record);
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Validate"),
|
|
name: "pom_validate",
|
|
label: "POM Validate",
|
|
description: "Run deterministic state, artifact, evidence, manifest, knowledge, continuity, and delivery checks.",
|
|
defaultInactive: true,
|
|
approval: "read",
|
|
parameters: z.object({
|
|
scope: z.enum(["quick", "stage", "canon", "continuity", "knowledge", "files", "delivery", "all"]).default("stage"),
|
|
}),
|
|
async execute(_id, params, signal, onUpdate) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
onUpdate?.({ content: [{ type: "text", text: `Validating ${params.scope}…` }] });
|
|
const report = await validatePom(runtime.get(), params.scope as ValidationScope);
|
|
const failures = report.checks.filter((item) => item.status === "fail").length;
|
|
runtime.telemetry.validationFailures = failures;
|
|
pi.sendMessage({ customType: "pom:validation", content: `${report.passed ? "PASS" : "FAIL"} ${params.scope}`, display: true, details: report }, { triggerTurn: false });
|
|
return textResult(`${report.passed ? "PASS" : "FAIL"} · ${failures} failures · ${report.checks.length} checks`, report, !report.passed);
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Prompt"),
|
|
name: "pom_prompt",
|
|
label: "POM Prompt",
|
|
description: "List or retrieve versioned POM prompt fragments, including project-local overrides and provenance hashes.",
|
|
defaultInactive: true,
|
|
approval: "read",
|
|
parameters: z.object({ action: z.enum(["list", "get"]), id: z.string().optional() }),
|
|
async execute(_id, params) {
|
|
const state = runtime.get().initialized ? runtime.get() : undefined;
|
|
if (params.action === "list") {
|
|
const prompts = await listPrompts(state);
|
|
return textResult(prompts.map((item) => `${item.id}\t${item.source}\t${item.sha256.slice(0, 12)}`).join("\n"), prompts);
|
|
}
|
|
if (!params.id) throw new Error("id is required");
|
|
const prompt = await getPrompt(state, params.id);
|
|
return textResult(prompt.content, prompt);
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Hive"),
|
|
name: "pom_hive",
|
|
label: "POM Hive",
|
|
description: "Plan native task batches, persist inter-agent signals, and record final synthesis without replacing OMP task or IRC.",
|
|
defaultInactive: true,
|
|
approval: "write",
|
|
parameters: z.object({
|
|
op: z.enum(["plan", "signal", "synthesize", "inspect"]),
|
|
preset: z.enum(["lean", "stage", "audit"]).optional(),
|
|
missionId: z.string().optional(),
|
|
signal: z.enum(["CLAIM", "QUERY", "ANSWER", "ALERT", "HANDOFF", "DONE"]).optional(),
|
|
from: z.string().optional(),
|
|
to: z.string().optional(),
|
|
message: z.string().optional(),
|
|
paths: z.array(z.string()).optional(),
|
|
status: z.enum(["complete", "blocked"]).optional(),
|
|
synthesis: z.string().optional(),
|
|
}),
|
|
async execute(_id, params, signal, _onUpdate, ctx) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
let state = structuredClone(runtime.get());
|
|
if (params.op === "inspect") return textResult(JSON.stringify(state.hive, null, 2), state.hive);
|
|
if (params.op === "plan") {
|
|
const config = await loadPomConfig(state.projectRoot);
|
|
const mission = buildHiveMission(state, config, params.preset ?? "stage");
|
|
const batch = missionToTaskBatch(state, mission);
|
|
state.hive.activeMissionId = mission.id;
|
|
state.hive.missions[mission.id] = mission;
|
|
state.stageRuns[String(state.currentStage)].hiveMissionIds.push(mission.id);
|
|
await runtime.set(state);
|
|
const path = await writeHiveMission(state, mission);
|
|
await recordHiveEvent(state, { type: "mission.planned", mission, path });
|
|
pi.sendMessage({ customType: "pom:hive", content: mission.title, display: true, details: mission }, { triggerTurn: false });
|
|
await refresh(pi, runtime, ctx);
|
|
return textResult(`Call native task exactly once with this batch:\n${JSON.stringify(batch, null, 2)}`, { mission, batch, path });
|
|
}
|
|
const missionId = params.missionId ?? state.hive.activeMissionId;
|
|
if (!missionId || !state.hive.missions[missionId]) throw new Error("No matching hive mission");
|
|
const mission = state.hive.missions[missionId];
|
|
if (params.op === "signal") {
|
|
if (!params.signal || !params.message) throw new Error("signal and message are required");
|
|
state.hive.signalsLogged += 1;
|
|
runtime.telemetry.lastIrcSignal = `${params.signal} ${params.from ?? "agent"}: ${params.message}`;
|
|
await runtime.set(state);
|
|
await recordHiveEvent(state, { type: "hive.signal", missionId, signal: params.signal, from: params.from, to: params.to, message: params.message, paths: params.paths ?? [] });
|
|
return textResult(`${params.signal} recorded for ${missionId}`, { missionId, ...params });
|
|
}
|
|
mission.status = params.status === "blocked" ? "blocked" : "complete";
|
|
mission.synthesis = params.synthesis?.trim() || "Synthesis recorded without narrative.";
|
|
mission.updatedAt = new Date().toISOString();
|
|
if (state.hive.activeMissionId === missionId) delete state.hive.activeMissionId;
|
|
await runtime.set(state);
|
|
const path = await writeHiveMission(state, mission);
|
|
await recordHiveEvent(state, { type: "mission.synthesized", missionId, status: mission.status, synthesis: mission.synthesis, path });
|
|
pi.sendMessage({ customType: "pom:hive", content: `${mission.title} ${mission.status}`, display: true, details: mission }, { triggerTurn: false });
|
|
return textResult(`Hive ${missionId} ${mission.status}`, { mission, path });
|
|
},
|
|
});
|
|
|
|
pi.registerTool({
|
|
...visual(runtime, "Export"),
|
|
name: "pom_export",
|
|
label: "POM Export",
|
|
description: "Create a fresh delivery archive, parse its central directory, decompress every member, verify sizes and CRC-32, and hash the archive.",
|
|
defaultInactive: true,
|
|
approval: "write",
|
|
parameters: z.object({ kind: z.enum(["checkpoint", "final"]).default("checkpoint") }),
|
|
async execute(_id, params, signal, onUpdate, ctx) {
|
|
if (signal?.aborted) return textResult("Cancelled", undefined, true);
|
|
onUpdate?.({ content: [{ type: "text", text: "Building and verifying archive…" }] });
|
|
const result = await exportProject(runtime.get(), params.kind);
|
|
await appendMarkdownLog(runtime.get().projectRoot, "delivery_ledger.md", "Archive verified", [
|
|
`Archive: ${result.zipPath}`,
|
|
`SHA-256: ${result.verification.sha256}`,
|
|
`Members: ${result.verification.members.length}`,
|
|
`Verification: ${result.verificationPath}`,
|
|
].join("\n\n"));
|
|
pi.sendMessage({ customType: "pom:milestone", content: "Archive verified", display: true, details: { stage: runtime.get().currentStage, status: "ARCHIVE PASS", path: result.verificationPath } }, { triggerTurn: false });
|
|
await refresh(pi, runtime, ctx);
|
|
return textResult(`PASS · ${result.zipPath} · ${result.verification.members.length} members`, result);
|
|
},
|
|
});
|
|
}
|