initial import: @mikefreno/omp-pygenium (omp port)
This commit is contained in:
463
src/modes/all.ts
Normal file
463
src/modes/all.ts
Normal file
@@ -0,0 +1,463 @@
|
||||
/**
|
||||
* modes/all.ts — `/pygienium-all` master orchestrator.
|
||||
*
|
||||
* Runs every registered check in sequence as ordered phases under a unified
|
||||
* status strip, with resumable state and a final summary report. This is the
|
||||
* piolium "balanced"/"deep" mode analogue, but simpler: one run, sequential
|
||||
* phases, shared recon (no scheduler — checks run one after another).
|
||||
*
|
||||
* Pipeline:
|
||||
* init single run (mode "all") → run shared recon once →
|
||||
* for each registered check (in registry order): call `runCheck` with the
|
||||
* SHARED run-state record (not a fresh one per check) → reconcile run
|
||||
* status → write `.pygienium/all-summary.md`.
|
||||
*
|
||||
* Resumability: terminal checks (`complete`/`skipped`) are skipped on resume;
|
||||
* `in_progress`/`failed`/`pending` checks re-run. `--fresh` resets every check
|
||||
* entry and re-runs the lot. `--only=comments,complexity` narrows the candidate
|
||||
* set to a named subset (registration order preserved).
|
||||
*
|
||||
* @module pygienium/modes/all
|
||||
*/
|
||||
|
||||
import { mkdir, writeFile } from "node:fs/promises";
|
||||
import { dirname, join, resolve } from "node:path";
|
||||
import type { ExtensionUIContext } from "@oh-my-pi/pi-coding-agent";
|
||||
import { getAllChecks, type CheckDefinition } from "../checks/registry.js";
|
||||
import { runCheck } from "./check-runner.js";
|
||||
import type { AgentSessionEvent } from "@oh-my-pi/pi-coding-agent";
|
||||
import { createPhaseStrip, type SendChatMessage } from "../phases.js";
|
||||
import { createPipelineFooter, type ItemStatus } from "../footer.js";
|
||||
import { runRecon } from "../recon.js";
|
||||
import {
|
||||
applyPhaseStatus,
|
||||
ensureRunStateIgnored,
|
||||
initRunState,
|
||||
loadRunState,
|
||||
markRunStatus,
|
||||
PHASE_RECON,
|
||||
reconcileRunStatus,
|
||||
resetCheckEntry,
|
||||
saveRunState,
|
||||
shouldRunOnResume,
|
||||
stateDir,
|
||||
type RunState,
|
||||
} from "../run-state.js";
|
||||
|
||||
/** Artifact directory name (relative to cwd) that holds `all-summary.md`. */
|
||||
export const ALL_ARTIFACT_DIR = ".pygienium";
|
||||
/** Filename for the unified per-check summary report. */
|
||||
export const ALL_SUMMARY_FILENAME = "all-summary.md";
|
||||
|
||||
/** Resolve `<cwd>/.pygienium/all-summary.md`. */
|
||||
export function allSummaryPath(cwd: string): string {
|
||||
return join(cwd, ALL_ARTIFACT_DIR, ALL_SUMMARY_FILENAME);
|
||||
}
|
||||
|
||||
export interface AllRunOptions {
|
||||
/** Working directory (from `ctx.cwd`). */
|
||||
cwd: string;
|
||||
/** Target path to scan (absolute; defaults to `cwd`). */
|
||||
target?: string;
|
||||
/** Whether fixes should be applied (`--fix`). */
|
||||
fix?: boolean;
|
||||
/** Subset of check names to run (`--only=comments,complexity`). */
|
||||
only?: string[];
|
||||
/** Reset and re-run every check, ignoring prior terminal state (`--fresh`). */
|
||||
fresh?: boolean;
|
||||
/**
|
||||
* Ensure `<cwd>/.gitignore` excludes `.pygienium/` before this run writes
|
||||
* state/artifacts (default true). Set false with `--no-gitignore`.
|
||||
*/
|
||||
gitignore?: boolean;
|
||||
/** UI context (optional; null in print mode). */
|
||||
ui?: ExtensionUIContext;
|
||||
/** Whether dialog-capable UI is available. */
|
||||
hasUI?: boolean;
|
||||
/** Optional callback to post completion messages into the chat. */
|
||||
sendChatMessage?: SendChatMessage;
|
||||
/** Optional callback forwarding raw sub-agent events to the chat stream. */
|
||||
onAgentEvent?: (phase: string, event: AgentSessionEvent) => void;
|
||||
/** Optional callback to emit synthetic progress lines during non-agent
|
||||
* phases (verify, cleanup, recon) into the chat stream. */
|
||||
sendPhaseLine?: (phase: string, text: string) => void;
|
||||
}
|
||||
|
||||
/** Outcome of {@link runAllChecks}. */
|
||||
export interface AllRunOutcome {
|
||||
/** Final run status. */
|
||||
status: RunState["status"];
|
||||
/** The updated run state. */
|
||||
state: RunState;
|
||||
/** Absolute path the summary was written to. */
|
||||
summaryPath: string;
|
||||
/** Checks that were actually dispatched (ran `runCheck`). */
|
||||
ran: string[];
|
||||
/** Checks skipped because they were already terminal. */
|
||||
skipped: string[];
|
||||
/** True when this run appended `.pygienium/` to the repo's .gitignore. */
|
||||
gitignoreAppended?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter the registry to the `only` subset, preserving insertion order.
|
||||
* Unknown names are silently dropped (a typo shouldn't abort an all-run).
|
||||
*/
|
||||
export function selectChecks(only?: string[]): CheckDefinition[] {
|
||||
const all = getAllChecks();
|
||||
if (!only || only.length === 0) return all;
|
||||
const set = new Set(only);
|
||||
return all.filter((c) => set.has(c.name));
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse `/pygienium-all` args: an optional `[path]` positional plus the
|
||||
* `--fix`, `--fresh`, and `--only=<a>,<b>` flags.
|
||||
*/
|
||||
export function parseAllArgs(
|
||||
args: string,
|
||||
cwd: string,
|
||||
): {
|
||||
target: string;
|
||||
fix: boolean;
|
||||
fresh: boolean;
|
||||
gitignore: boolean;
|
||||
only: string[];
|
||||
} {
|
||||
const tokens = args.trim().length > 0 ? args.trim().split(/\s+/) : [];
|
||||
let fix = false;
|
||||
let fresh = false;
|
||||
let gitignore = true;
|
||||
let target = cwd;
|
||||
const only: string[] = [];
|
||||
for (const tok of tokens) {
|
||||
if (tok === "--fix") {
|
||||
fix = true;
|
||||
} else if (tok === "--fresh") {
|
||||
fresh = true;
|
||||
} else if (tok === "--no-gitignore") {
|
||||
gitignore = false;
|
||||
} else if (tok.startsWith("--only=")) {
|
||||
for (const name of tok.slice("--only=".length).split(",")) {
|
||||
const trimmed = name.trim();
|
||||
if (trimmed) only.push(trimmed);
|
||||
}
|
||||
} else if (!tok.startsWith("--")) {
|
||||
target = tok;
|
||||
}
|
||||
}
|
||||
return { target: resolve(cwd, target), fix, fresh, gitignore, only };
|
||||
}
|
||||
|
||||
/** Count non-empty lines in captured findings/changes text. */
|
||||
function lineCount(text: string | undefined): number {
|
||||
if (!text) return 0;
|
||||
return text.split(/\r?\n/).filter((l) => l.trim().length > 0).length;
|
||||
}
|
||||
|
||||
function toISO(ms: number | undefined): string {
|
||||
return ms == null ? "—" : new Date(ms).toISOString();
|
||||
}
|
||||
|
||||
function short(status: string): string {
|
||||
return status[0]?.toUpperCase() ?? "?";
|
||||
}
|
||||
|
||||
/**
|
||||
* Render the unified summary markdown from run-state. Lists per-check
|
||||
* outcomes: status, artifact paths (when present on disk), findings/changes
|
||||
* line counts, phase breakdown, and errors.
|
||||
*/
|
||||
export function renderAllSummary(
|
||||
state: RunState,
|
||||
selected: CheckDefinition[],
|
||||
): string {
|
||||
const lines: string[] = [];
|
||||
lines.push("# Pygienium all-run summary");
|
||||
lines.push("");
|
||||
lines.push(`- status: ${state.status}`);
|
||||
lines.push(`- started: ${toISO(state.startedAt)}`);
|
||||
lines.push(`- updated: ${toISO(state.updatedAt)}`);
|
||||
lines.push(`- cwd: ${state.cwd}`);
|
||||
lines.push(`- recon: ${state.recon.complete ? "complete" : "pending"}`);
|
||||
lines.push(`- checks: ${selected.length}`);
|
||||
lines.push("");
|
||||
|
||||
for (const check of selected) {
|
||||
const entry = state.checks[check.name];
|
||||
const fixTag = entry?.fix ? " (--fix)" : "";
|
||||
lines.push(`## ${check.name} — ${entry?.status ?? "pending"}${fixTag}`);
|
||||
lines.push("");
|
||||
|
||||
// Errors are terminal-run facts: a check that completed via a later
|
||||
// resume/retry must not surface a stale error under a "complete"
|
||||
// status (markCheckStatus clears it on success; this guard covers
|
||||
// hand-edited or legacy state files too).
|
||||
if (entry?.error && entry?.status !== "complete") {
|
||||
lines.push(`- error: ${entry.error}`);
|
||||
}
|
||||
|
||||
// Artifact paths (canonical root: `.pygienium/checks/<name>/`).
|
||||
const findingsPath = `${state.cwd}/.pygienium/checks/${check.name}/findings.md`;
|
||||
const changesPath = `${state.cwd}/.pygienium/checks/${check.name}/changes.md`;
|
||||
const fLines = lineCount(entry?.findings);
|
||||
const cLines = lineCount(entry?.changes);
|
||||
if (fLines > 0) {
|
||||
lines.push(`- findings: ${findingsPath} (${fLines} line(s))`);
|
||||
}
|
||||
if (cLines > 0) {
|
||||
lines.push(`- changes: ${changesPath} (${cLines} line(s))`);
|
||||
}
|
||||
|
||||
// Phase breakdown for transparency.
|
||||
if (entry?.phases?.length) {
|
||||
const phaseSummary = entry.phases
|
||||
.map(
|
||||
(p) =>
|
||||
`${p.id}:${
|
||||
p.status.startsWith("in_progress") ? "…" : short(p.status)
|
||||
}`,
|
||||
)
|
||||
.join(" ");
|
||||
lines.push(`- phases: ${phaseSummary}`);
|
||||
}
|
||||
|
||||
lines.push("");
|
||||
}
|
||||
|
||||
return lines.join("\n") + "\n";
|
||||
}
|
||||
|
||||
/**
|
||||
* Run every registered check in sequence under a unified status strip.
|
||||
*
|
||||
* Resumable: terminal checks skip on resume unless `fresh` resets them.
|
||||
*/
|
||||
export async function runAllChecks(
|
||||
opts: AllRunOptions,
|
||||
): Promise<AllRunOutcome> {
|
||||
const { cwd } = opts;
|
||||
const target = opts.target ?? cwd;
|
||||
const fix = opts.fix ?? false;
|
||||
const fresh = opts.fresh ?? false;
|
||||
const hasUI = opts.hasUI ?? false;
|
||||
|
||||
// Keep pygienium's own output out of the scanned repo's git index unless
|
||||
// the caller opted out with --no-gitignore.
|
||||
const gitignoreAppended =
|
||||
opts.gitignore === false ? false : await ensureRunStateIgnored(cwd);
|
||||
|
||||
const selected = selectChecks(opts.only);
|
||||
if (selected.length === 0) {
|
||||
// `--only` selected nothing (or no checks registered). Still produce a
|
||||
// summary so the caller has an artifact.
|
||||
const state = (await loadRunState(cwd)) ?? initRunState(cwd, []);
|
||||
markRunStatus(state, reconcileRunStatus(state));
|
||||
await saveRunState(state);
|
||||
const summaryPath = await writeAllSummary(state, []);
|
||||
return {
|
||||
status: state.status,
|
||||
state,
|
||||
summaryPath,
|
||||
ran: [],
|
||||
skipped: [],
|
||||
gitignoreAppended,
|
||||
};
|
||||
}
|
||||
|
||||
// --- Init / resume the single shared run-state --------------------------
|
||||
let state =
|
||||
(await loadRunState(cwd)) ??
|
||||
initRunState(
|
||||
cwd,
|
||||
selected.map((c) => ({ name: c.name, label: c.label, fix })),
|
||||
);
|
||||
|
||||
// Ensure every selected check has an entry (adds any missing on resume).
|
||||
for (const check of selected) {
|
||||
if (!state.checks[check.name]) {
|
||||
state.checks[check.name] = {
|
||||
name: check.name,
|
||||
label: check.label,
|
||||
status: "pending",
|
||||
fix,
|
||||
phases: [
|
||||
{ id: "recon", status: "pending" },
|
||||
{ id: "analysis", status: "pending" },
|
||||
...(fix ? [{ id: "fix", status: "pending" as const }] : []),
|
||||
{ id: "verify", status: "pending" },
|
||||
{ id: "cleanup", status: "pending" },
|
||||
],
|
||||
};
|
||||
}
|
||||
}
|
||||
await saveRunState(state);
|
||||
|
||||
// --- Unified phase strip logging all check names -----------------------
|
||||
const strip = createPhaseStrip({
|
||||
ui: opts.ui,
|
||||
hasUI,
|
||||
});
|
||||
setAllPhase(strip, selected, 0, "recon");
|
||||
|
||||
// Pipeline-overview footer: a multi-line widget listing every check with the
|
||||
// cursor on the active one and what's to come. Detail lives in the chat
|
||||
// (per-check completion trees); the footer is the overview. Inner
|
||||
// `runCheck` calls pass `footer: false` so two overviews never compete.
|
||||
const allFooter = createPipelineFooter({
|
||||
ui: opts.ui,
|
||||
hasUI,
|
||||
statusKey: "pygienium-all",
|
||||
});
|
||||
const allItems = selected.map((c) => ({
|
||||
label: c.label,
|
||||
status: "pending" as ItemStatus,
|
||||
}));
|
||||
allFooter.setPipeline("pygienium: all", allItems, 0);
|
||||
const footerSettle = (name: string, status: ItemStatus): void => {
|
||||
const idx = selected.findIndex((c) => c.name === name);
|
||||
if (idx >= 0) allFooter.setItem(idx, status);
|
||||
};
|
||||
|
||||
// --- Shared recon (run once before any check) ---------------------------
|
||||
if (!state.recon.complete) {
|
||||
const snapshot = await runRecon(cwd);
|
||||
state.recon = {
|
||||
complete: true,
|
||||
path: join(stateDir(cwd), "recon.json"),
|
||||
finishedAt: snapshot.createdAt,
|
||||
};
|
||||
// Mark recon complete for every selected check that hasn't run it yet.
|
||||
for (const check of selected) {
|
||||
applyPhaseStatus(state, check.name, PHASE_RECON, "complete");
|
||||
}
|
||||
await saveRunState(state);
|
||||
}
|
||||
|
||||
const ran: string[] = [];
|
||||
const skipped: string[] = [];
|
||||
|
||||
// --- Per-check loop (shared run-state, registry order) ------------------
|
||||
for (let i = 0; i < selected.length; i++) {
|
||||
const check = selected[i]!;
|
||||
setAllPhase(strip, selected, i, "analysis");
|
||||
allFooter.setCursor(i);
|
||||
|
||||
const entry = state.checks[check.name];
|
||||
// Resumability: skip terminal checks unless --fresh.
|
||||
if (entry && !shouldRunOnResume(entry, fresh)) {
|
||||
skipped.push(check.name);
|
||||
footerSettle(
|
||||
check.name,
|
||||
entry.status === "complete" ? "skipped" : "skipped",
|
||||
);
|
||||
strip.log(
|
||||
`pygienium: ${check.label} — already ${entry.status}, skipping`,
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (fresh && entry) {
|
||||
resetCheckEntry(state, check.name, fix);
|
||||
await saveRunState(state);
|
||||
}
|
||||
|
||||
strip.log(`pygienium: running ${check.label}…`);
|
||||
const outcome = await runCheck({
|
||||
check,
|
||||
cwd,
|
||||
scope: { cwd, target, fix, rest: [] },
|
||||
ui: opts.ui,
|
||||
hasUI,
|
||||
existingState: state,
|
||||
sendChatMessage: opts.sendChatMessage,
|
||||
onAgentEvent: opts.onAgentEvent,
|
||||
sendPhaseLine: opts.sendPhaseLine,
|
||||
// The all-run footer already owns the pipeline-overview widget
|
||||
// slot; suppress the per-check footer so two overviews never
|
||||
// compete over the same `belowEditor` area.
|
||||
footer: false,
|
||||
// Inner runs must not prime the .gitignore twice — the outer all-run
|
||||
// already ensured it. (ensureRunStateIgnored is memoized per cwd,
|
||||
// so this is belt-and-braces.)
|
||||
gitignore: opts.gitignore,
|
||||
});
|
||||
state = outcome.state;
|
||||
ran.push(check.name);
|
||||
footerSettle(
|
||||
check.name,
|
||||
outcome.status === "complete"
|
||||
? "complete"
|
||||
: outcome.status === "skipped"
|
||||
? "skipped"
|
||||
: "failed",
|
||||
);
|
||||
strip.log(`pygienium ${check.label}: ${outcome.status}`);
|
||||
}
|
||||
|
||||
// --- Finalize -----------------------------------------------------------
|
||||
markRunStatus(state, reconcileRunStatus(state));
|
||||
await saveRunState(state);
|
||||
|
||||
setAllPhase(strip, selected, selected.length - 1, "cleanup");
|
||||
// Mark the final check's footer status terminal; the cursor started at 0
|
||||
// and the loop advanced it, so the last selected item is the live one.
|
||||
if (selected.length > 0) {
|
||||
footerSettle(
|
||||
selected[selected.length - 1]!.name,
|
||||
state.checks[selected[selected.length - 1]!.name]?.status === "failed"
|
||||
? "failed"
|
||||
: "complete",
|
||||
);
|
||||
}
|
||||
strip.done();
|
||||
allFooter.done();
|
||||
|
||||
const summaryPath = await writeAllSummary(state, selected);
|
||||
|
||||
return {
|
||||
status: state.status,
|
||||
state,
|
||||
summaryPath,
|
||||
ran,
|
||||
skipped,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the unified strip to reflect which check is active and its phase.
|
||||
* Renders `pygienium: all [i/N] <check-label>: <phase>` so every check name is
|
||||
* surfaced in the strip over the course of the run.
|
||||
*/
|
||||
function setAllPhase(
|
||||
strip: ReturnType<typeof createPhaseStrip>,
|
||||
selected: CheckDefinition[],
|
||||
index: number,
|
||||
phaseId: string,
|
||||
): void {
|
||||
const check = selected[index];
|
||||
const label = check?.label ?? "(none)";
|
||||
const total = selected.length;
|
||||
const pos = String(index + 1);
|
||||
const phaseLabel = PHASE_ALL_LABELS[phaseId] ?? phaseId;
|
||||
strip.setPhase(`all [${pos}/${total}] ${label}: ${phaseLabel}`);
|
||||
}
|
||||
|
||||
const PHASE_ALL_LABELS: Record<string, string> = {
|
||||
recon: "Recon",
|
||||
analysis: "Scanning",
|
||||
fix: "Fixing",
|
||||
verify: "Verifying",
|
||||
cleanup: "Done",
|
||||
};
|
||||
|
||||
/** Write the all-summary.md report, creating the directory as needed. */
|
||||
async function writeAllSummary(
|
||||
state: RunState,
|
||||
selected: CheckDefinition[],
|
||||
): Promise<string> {
|
||||
const path = allSummaryPath(state.cwd);
|
||||
await mkdir(dirname(path), { recursive: true });
|
||||
await writeFile(path, renderAllSummary(state, selected), "utf8");
|
||||
return path;
|
||||
}
|
||||
Reference in New Issue
Block a user