parallel-codex-tui 0.1.0 → 0.1.4

package/dist/cli.js

@@ -1,48 +1,304 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
+import { join } from "node:path";
 import { render } from "ink";
-import { parseCliArgs } from "./cli-args.js";
+import { ZodError } from "zod";
+import { parseCliArgs, validateCliArgs } from "./cli-args.js";
+import { selectWorkspaceForCli } from "./cli-workspace.js";
+import { commitWorkspaceTransition } from "./cli-workspace-transition.js";
+import { WorkspaceSelectionCancelledError } from "./cli-workspace-picker.js";
+import { startupRecoveryMessages } from "./cli-startup-recovery.js";
 import { createRuntime } from "./bootstrap.js";
-import { configPath, writeDefaultConfig } from "./core/config.js";
+import { prepareAppRoot } from "./core/app-root.js";
+import { formatConfigErrorMessage } from "./core/config-errors.js";
+import { configPath, loadConfig, withUiThemeOverride, writeDefaultConfig } from "./core/config.js";
 import { pathExists } from "./core/file-store.js";
+import { readRouterAudit } from "./core/router-audit.js";
+import { listWorkspaceChoices } from "./core/workspace.js";
 import { runDoctor } from "./doctor.js";
+import { helpText } from "./cli-help.js";
 import { App } from "./tui/App.js";
+import { formatTuiThemeCatalog } from "./tui/theme-preview.js";
+import { configureTuiTheme } from "./tui/theme.js";
+import { routerDiagnosticsPolicy } from "./tui/RouterDiagnosticsView.js";
 import { version } from "./version.js";
-const helpText = `Usage: parallel-codex-tui [options]
-
-Options:
-  -w, --workspace <path>  Project workspace for worker sessions and edits
-      --app-root <path>   App root for configuration lookup
-  -t, --task <id>         Open an existing task session
-      --init              Write .parallel-codex/config.toml if missing
-      --doctor            Check local configuration and agent commands
-  -v, --version           Print the current version
-  -h, --help              Print this help message`;
-const cliArgs = parseCliArgs(process.argv.slice(2), process.cwd());
-const localConfigPath = configPath(cliArgs.appRoot);
-if (cliArgs.help) {
-    console.log(helpText);
-}
-else if (cliArgs.version) {
-    console.log(`parallel-codex-tui ${version}`);
-}
-else if (cliArgs.doctor) {
-    const result = await runDoctor(cliArgs.appRoot, cliArgs.workspaceRoot);
-    process.stdout.write(result.text);
-    process.exitCode = result.ok ? 0 : 1;
-}
-else if (cliArgs.init) {
-    if (await pathExists(localConfigPath)) {
-        console.log(`Config already exists: ${localConfigPath}`);
+main().catch((error) => {
+    if (error instanceof WorkspaceSelectionCancelledError) {
+        return;
+    }
+    process.stderr.write(`${formatStartupError(error)}\n`);
+    process.exit(1);
+});
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    const cliArgErrors = validateCliArgs(rawArgs);
+    if (cliArgErrors.length > 0) {
+        process.stderr.write(`${cliArgErrors.join("\n")}\n`);
+        process.exit(1);
+    }
+    const cliArgs = parseCliArgs(rawArgs, process.cwd());
+    if (!cliArgs.help && !cliArgs.themes && !cliArgs.version) {
+        await prepareAppRoot(cliArgs.appRoot);
+    }
+    const localConfigPath = configPath(cliArgs.appRoot);
+    if (cliArgs.help) {
+        console.log(helpText);
+    }
+    else if (cliArgs.version) {
+        console.log(`parallel-codex-tui ${version}`);
+    }
+    else if (cliArgs.themes) {
+        console.log(formatTuiThemeCatalog(cliArgs.theme ? [cliArgs.theme] : undefined).join("\n"));
+    }
+    else if (cliArgs.doctor) {
+        const workspaceRoot = await selectWorkspaceForCli({
+            appRoot: cliArgs.appRoot,
+            cwd: process.cwd(),
+            explicitWorkspace: cliArgs.explicitWorkspace,
+            interactive: false
+        });
+        const result = await runDoctor(cliArgs.appRoot, workspaceRoot, process.env, {
+            probeAgents: cliArgs.probeAgents,
+            probeRouter: cliArgs.probeRouter,
+            theme: cliArgs.theme
+        });
+        process.stdout.write(result.text);
+        process.exitCode = result.ok ? 0 : 1;
+    }
+    else if (cliArgs.init) {
+        if (await pathExists(localConfigPath)) {
+            console.log(`Config already exists: ${localConfigPath}`);
+        }
+        else {
+            await writeDefaultConfig(cliArgs.appRoot);
+            console.log(`Wrote ${localConfigPath}`);
+        }
     }
     else {
-        await writeDefaultConfig(cliArgs.appRoot);
-        console.log(`Wrote ${localConfigPath}`);
+        const startupConfig = await loadConfig(cliArgs.appRoot);
+        configureTuiTheme({
+            theme: cliArgs.theme ?? startupConfig.ui.theme,
+            colors: startupConfig.ui.colors
+        });
+        const workspaceRoot = await selectWorkspaceForCli({
+            appRoot: cliArgs.appRoot,
+            cwd: process.cwd(),
+            explicitWorkspace: cliArgs.explicitWorkspace
+        });
+        let current = await loadInteractiveWorkspace(cliArgs.appRoot, workspaceRoot, cliArgs.taskId);
+        if (!canRenderInteractiveTui()) {
+            current.runtime.index.close();
+            throw new Error("parallel-codex-tui requires an interactive terminal. Use --help, --version, --init, or --doctor for non-interactive command modes.");
+        }
+        let instance = null;
+        const shutdownController = new AbortController();
+        const deferredWorkspaceClosures = new Set();
+        const appElement = (state) => (_jsx(App, { config: withUiThemeOverride(state.runtime.config, cliArgs.theme), orchestrator: state.runtime.orchestrator, cwd: state.runtime.workspaceRoot, initialTaskId: state.initialTaskId, initialRoute: state.initialRoute, initialWorkers: state.initialWorkers, initialCanRetryTask: state.initialCanRetryTask, initialMessages: state.initialMessages, workspaceChoices: state.workspaceChoices, shutdownSignal: shutdownController.signal, loadRouterDiagnostics: async () => {
+                const [records, latestConfig] = await Promise.all([
+                    readRouterAudit(join(state.runtime.routerCwd, "routes.jsonl"), 100),
+                    loadConfig(cliArgs.appRoot)
+                ]);
+                return {
+                    records,
+                    policy: routerDiagnosticsPolicy(latestConfig.router)
+                };
+            }, loadTaskSessions: (options) => state.runtime.index.listTasks(100, options), renameTaskSession: async (taskId, title) => {
+                await state.runtime.sessions.renameTask(taskId, title);
+            }, setTaskSessionArchived: async (taskId, archived) => {
+                await state.runtime.sessions.setTaskArchived(taskId, archived);
+            }, deleteTaskSession: async (taskId) => {
+                await state.runtime.sessions.deleteTask(taskId);
+            }, exportTaskSession: async (taskId) => (await state.runtime.sessions.exportTask(taskId)).path, loadCollaborationTimeline: (taskId) => state.runtime.sessions.readCollaborationTimeline(taskId), activateTaskSession: async (taskId) => {
+                if (!taskId) {
+                    await state.runtime.index.setActiveTaskId(null);
+                    return null;
+                }
+                if (!(await state.runtime.sessions.hasTask(taskId))) {
+                    throw new Error(`Task session not found in workspace ${state.runtime.workspaceRoot}: ${taskId}`);
+                }
+                const task = state.runtime.sessions.taskFromId(taskId);
+                const meta = await state.runtime.sessions.readMeta(task);
+                if (meta.archived_at) {
+                    throw new Error(`Task session is archived: ${taskId}`);
+                }
+                const [route, workers, canRetry] = await Promise.all([
+                    state.runtime.sessions.readLatestRoute(task),
+                    state.runtime.orchestrator.listTaskWorkers(taskId),
+                    state.runtime.orchestrator.canRetryTask(taskId)
+                ]);
+                await state.runtime.index.setActiveTaskId(taskId);
+                return { taskId, route, workers, canRetry };
+            }, switchWorkspace: async (workspace) => {
+                if (workspace === current.runtime.workspaceRoot) {
+                    return;
+                }
+                retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
+                const next = await loadInteractiveWorkspace(cliArgs.appRoot, workspace, null);
+                const previous = current;
+                current = commitWorkspaceTransition({
+                    previous,
+                    next,
+                    render: (state) => {
+                        if (!instance) {
+                            throw new Error("Interactive TUI is not ready to switch workspaces.");
+                        }
+                        instance.rerender(appElement(state));
+                    },
+                    close: closeInteractiveWorkspace,
+                    deferClose: (state) => deferredWorkspaceClosures.add(state)
+                });
+            }, persistChatMessage: (message, taskId) => state.runtime.sessions.appendChatMessage({
+                ...message,
+                taskId
+            }) }, state.runtime.workspaceRoot));
+        const removeSigintHandler = installInteractiveSigintExitHandler(() => shutdownController.abort());
+        try {
+            instance = render(appElement(current), { exitOnCtrlC: false });
+            await instance.waitUntilExit();
+        }
+        finally {
+            removeSigintHandler();
+            retryDeferredWorkspaceClosures(deferredWorkspaceClosures);
+        }
+    }
+}
+async function loadInteractiveWorkspace(appRoot, workspaceRoot, requestedTaskId) {
+    const runtime = await createRuntime(appRoot, workspaceRoot);
+    try {
+        if (requestedTaskId) {
+            if (!(await runtime.sessions.hasTask(requestedTaskId))) {
+                throw new Error(`Task session not found in workspace ${runtime.workspaceRoot}: ${requestedTaskId}`);
+            }
+            const requestedMeta = await runtime.sessions.readMeta(runtime.sessions.taskFromId(requestedTaskId));
+            if (requestedMeta.archived_at) {
+                throw new Error(`Task session is archived in workspace ${runtime.workspaceRoot}: ${requestedTaskId}`);
+            }
+        }
+        const [latestTask, rememberedTaskId] = await Promise.all([
+            runtime.sessions.latestTask(),
+            runtime.index.activeTaskId()
+        ]);
+        const rememberedTaskIsRestorable = typeof rememberedTaskId === "string"
+            && await runtime.sessions.hasTask(rememberedTaskId)
+            && !(await runtime.sessions.readMeta(runtime.sessions.taskFromId(rememberedTaskId))).archived_at;
+        let initialTaskId;
+        if (requestedTaskId) {
+            initialTaskId = requestedTaskId;
+        }
+        else if (rememberedTaskId === null) {
+            initialTaskId = null;
+        }
+        else if (rememberedTaskId && rememberedTaskIsRestorable) {
+            initialTaskId = rememberedTaskId;
+        }
+        else {
+            initialTaskId = latestTask?.id ?? null;
+        }
+        if (initialTaskId && initialTaskId !== rememberedTaskId) {
+            await runtime.index.setActiveTaskId(initialTaskId);
+        }
+        else if (!initialTaskId && typeof rememberedTaskId === "string") {
+            await runtime.index.setActiveTaskId(null);
+        }
+        const [initialRoute, initialWorkers, initialCanRetryTask, initialHistory, workspaceChoices] = await Promise.all([
+            initialTaskId
+                ? runtime.sessions.readLatestRoute(runtime.sessions.taskFromId(initialTaskId))
+                : null,
+            initialTaskId ? runtime.orchestrator.listTaskWorkers(initialTaskId) : [],
+            initialTaskId ? runtime.orchestrator.canRetryTask(initialTaskId) : false,
+            runtime.sessions.readChatHistory(),
+            listWorkspaceChoices(appRoot)
+        ]);
+        const recoveryMessages = startupRecoveryMessages(runtime.recoveredTasks, initialTaskId, runtime.pendingTaskCreations);
+        return {
+            runtime,
+            initialTaskId,
+            initialRoute,
+            initialWorkers,
+            initialCanRetryTask,
+            initialMessages: [
+                ...initialHistory.map(({ from, text, task_id }) => ({
+                    from,
+                    text,
+                    ...(task_id ? { taskId: task_id } : {})
+                })),
+                ...recoveryMessages
+            ],
+            workspaceChoices
+        };
+    }
+    catch (error) {
+        runtime.index.close();
+        throw error;
+    }
+}
+function closeInteractiveWorkspace(state) {
+    state.runtime.index.close();
+}
+function retryDeferredWorkspaceClosures(states) {
+    for (const state of states) {
+        try {
+            closeInteractiveWorkspace(state);
+            states.delete(state);
+        }
+        catch {
+            // Process exit remains the final cleanup boundary if an index cannot be closed yet.
+        }
     }
 }
-else {
-    const runtime = await createRuntime(cliArgs.appRoot, cliArgs.workspaceRoot);
-    const latestTask = await runtime.sessions.latestTask();
-    const initialTaskId = cliArgs.taskId ?? latestTask?.id ?? null;
-    render(_jsx(App, { config: runtime.config, orchestrator: runtime.orchestrator, cwd: runtime.workspaceRoot, initialTaskId: initialTaskId }), { exitOnCtrlC: false });
+function canRenderInteractiveTui() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function installInteractiveSigintExitHandler(requestGracefulExit) {
+    let interrupted = false;
+    const onSigint = () => {
+        if (!interrupted) {
+            interrupted = true;
+            try {
+                requestGracefulExit();
+                return;
+            }
+            catch {
+                // Fall through to the force-exit path when graceful shutdown cannot start.
+            }
+        }
+        restoreInteractiveTerminal();
+        process.exit(0);
+    };
+    process.on("SIGINT", onSigint);
+    return () => process.off("SIGINT", onSigint);
+}
+function restoreInteractiveTerminal() {
+    if (process.stdin.isTTY && process.stdin.isRaw && typeof process.stdin.setRawMode === "function") {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch {
+            // The active view may already be releasing raw mode.
+        }
+    }
+    process.stdin.pause();
+    if (process.stdout.isTTY) {
+        process.stdout.write("\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h");
+    }
+}
+function formatStartupError(error) {
+    const message = isConfigStartupError(error)
+        ? formatConfigErrorMessage(error)
+        : error instanceof Error ? error.message : String(error);
+    if (isConfigStartupError(error)) {
+        return `Config error: ${message}\nRun parallel-codex-tui --doctor for details.`;
+    }
+    return `Startup error: ${message}`;
+}
+function isConfigStartupError(error) {
+    if (error instanceof ZodError) {
+        return true;
+    }
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.message.startsWith("Invalid config section ") ||
+        error.name.toLowerCase().includes("toml") ||
+        error.message.toLowerCase().includes("toml"));
 }

package/dist/core/app-root.js

@@ -0,0 +1,8 @@
+import { ensureDir, pathExists, pathIsDirectory } from "./file-store.js";
+export async function prepareAppRoot(appRoot) {
+    if ((await pathExists(appRoot)) && !(await pathIsDirectory(appRoot))) {
+        throw new Error(`App root path exists but is not a directory: ${appRoot}`);
+    }
+    await ensureDir(appRoot);
+    return appRoot;
+}

package/dist/core/collaboration-timeline.js

@@ -0,0 +1,261 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { EventRecordSchema, FeatureStatusSchema } from "../domain/schemas.js";
+import { readTextIfExists } from "./file-store.js";
+const FeatureDialogueSchema = z.object({
+    time: z.string().datetime(),
+    feature_id: z.string().min(1),
+    turn_id: z.string().min(1),
+    type: z.string().min(1),
+    role: z.enum(["actor", "critic"]),
+    message: z.string().default(""),
+    paths: z.record(z.string()).default({})
+});
+const FindingResolutionSchema = z.object({
+    version: z.literal(1),
+    decision: z.enum(["pending", "approved", "inconsistent"]),
+    fixed_ids: z.array(z.string().min(1)),
+    unresolved_ids: z.array(z.string().min(1))
+});
+export async function loadCollaborationTimeline(taskId, taskDir) {
+    const [features, dialogueText, taskEventsText] = await Promise.all([
+        readCollaborationFeatures(taskDir),
+        readTextIfExists(join(taskDir, "dialogue", "actor-critic.jsonl")),
+        readTextIfExists(join(taskDir, "events.jsonl"))
+    ]);
+    const featureById = new Map(features.map((feature) => [feature.id, feature]));
+    const dialogue = parseJsonLines(dialogueText, FeatureDialogueSchema);
+    const taskEvents = parseJsonLines(taskEventsText, EventRecordSchema)
+        .filter((event) => event.type.startsWith("feature.wave_"));
+    const events = [
+        ...dialogue.map((event, index) => {
+            const feature = featureById.get(event.feature_id);
+            const artifactRefs = collaborationArtifactRefs(event.paths ?? {});
+            return {
+                id: `dialogue-${index}-${event.time}`,
+                time: event.time,
+                type: event.type,
+                role: event.role,
+                action: collaborationDialogueAction(event.type),
+                message: event.type === "critic.revision_requested" && feature?.latestFinding
+                    ? appendCollaborationEvidence(event.message ?? "", feature.latestFinding)
+                    : event.message ?? "",
+                turnId: event.turn_id,
+                featureId: event.feature_id,
+                featureTitle: feature?.title ?? event.feature_id,
+                findings: feature?.findings ?? 0,
+                replies: feature?.replies ?? 0,
+                ...(typeof feature?.resolvedFindings === "number"
+                    ? { resolvedFindings: feature.resolvedFindings }
+                    : {}),
+                ...(typeof feature?.unresolvedFindings === "number"
+                    ? { unresolvedFindings: feature.unresolvedFindings }
+                    : {}),
+                artifacts: artifactRefs.map((artifact) => artifact.label),
+                artifactRefs
+            };
+        }),
+        ...taskEvents.map((event, index) => ({
+            id: `task-${index}-${event.time}`,
+            time: event.time,
+            type: event.type,
+            role: "supervisor",
+            action: collaborationWaveAction(event.type),
+            message: event.message ?? "",
+            artifacts: ["task events"],
+            artifactRefs: [{ label: "task events", path: join(taskDir, "events.jsonl") }]
+        })),
+        ...features.map((feature) => ({
+            id: `state-${feature.id}-${feature.updatedAt}`,
+            time: feature.updatedAt,
+            type: "feature.state",
+            role: "supervisor",
+            action: collaborationFeatureStateAction(feature.state),
+            message: [
+                `${feature.title} · ${humanizeFeatureState(feature.state)}`,
+                ...(feature.latestFinding ? [`finding: ${feature.latestFinding}`] : []),
+                ...(feature.latestReply ? [`reply: ${feature.latestReply}`] : [])
+            ].join(" · "),
+            turnId: feature.turnId,
+            featureId: feature.id,
+            featureTitle: feature.title,
+            findings: feature.findings,
+            replies: feature.replies,
+            ...(typeof feature.resolvedFindings === "number"
+                ? { resolvedFindings: feature.resolvedFindings }
+                : {}),
+            ...(typeof feature.unresolvedFindings === "number"
+                ? { unresolvedFindings: feature.unresolvedFindings }
+                : {}),
+            artifacts: feature.artifactRefs.map((artifact) => artifact.label),
+            artifactRefs: feature.artifactRefs
+        }))
+    ].sort((left, right) => left.time.localeCompare(right.time) || left.id.localeCompare(right.id));
+    return { taskId, features, events };
+}
+async function readCollaborationFeatures(taskDir) {
+    const root = join(taskDir, "features");
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const features = await Promise.all(entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => {
+        const dir = join(root, entry.name);
+        const [statusText, spec, findings, replies, resolutionText] = await Promise.all([
+            readTextIfExists(join(dir, "status.json")),
+            readTextIfExists(join(dir, "spec.md")),
+            readTextIfExists(join(dir, "critic-findings.jsonl")),
+            readTextIfExists(join(dir, "actor-replies.jsonl")),
+            readTextIfExists(join(dir, "finding-resolution.json"))
+        ]);
+        const status = parseJsonValue(statusText, FeatureStatusSchema);
+        if (!status) {
+            return null;
+        }
+        const findingEvidence = readMailboxEvidence(findings);
+        const replyEvidence = readMailboxEvidence(replies);
+        const resolution = parseJsonValue(resolutionText, FindingResolutionSchema);
+        return {
+            id: status.feature_id,
+            title: status.title?.trim() || featureSpecTitle(spec) || status.feature_id,
+            description: status.description?.trim() ?? "",
+            dependsOn: status.depends_on ?? [],
+            turnId: status.turn_id,
+            state: status.state,
+            updatedAt: status.updated_at,
+            findings: findingEvidence.count,
+            replies: replyEvidence.count,
+            artifactRefs: [
+                { label: "status", path: join(dir, "status.json") },
+                { label: "spec", path: join(dir, "spec.md") },
+                { label: "critic findings", path: join(dir, "critic-findings.jsonl") },
+                { label: "actor replies", path: join(dir, "actor-replies.jsonl") },
+                ...(resolution ? [{ label: "finding resolution", path: join(dir, "finding-resolution.json") }] : [])
+            ],
+            ...(resolution
+                ? {
+                    resolvedFindings: new Set(resolution.fixed_ids).size,
+                    unresolvedFindings: new Set(resolution.unresolved_ids).size
+                }
+                : {}),
+            ...(findingEvidence.latest ? { latestFinding: findingEvidence.latest } : {}),
+            ...(replyEvidence.latest ? { latestReply: replyEvidence.latest } : {})
+        };
+    }));
+    return features
+        .filter((feature) => feature !== null)
+        .sort((left, right) => left.turnId.localeCompare(right.turnId) || left.id.localeCompare(right.id));
+}
+function collaborationArtifactRefs(paths) {
+    return Object.entries(paths)
+        .map(([label, path]) => ({ label: label.trim(), path: path.trim() }))
+        .filter((artifact) => artifact.label && artifact.path)
+        .sort((left, right) => left.label.localeCompare(right.label) || left.path.localeCompare(right.path));
+}
+function parseJsonLines(text, schema) {
+    const records = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const parsed = schema.safeParse(JSON.parse(line));
+            if (parsed.success) {
+                records.push(parsed.data);
+            }
+        }
+        catch {
+            // A partial mailbox write must not hide earlier collaboration evidence.
+        }
+    }
+    return records;
+}
+function parseJsonValue(text, schema) {
+    try {
+        const parsed = schema.safeParse(JSON.parse(text));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readMailboxEvidence(text) {
+    let count = 0;
+    let latest = null;
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const value = JSON.parse(line);
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                count += 1;
+                latest = mailboxRecordSummary(value) || latest;
+            }
+        }
+        catch {
+            // Ignore partial or malformed mailbox rows.
+        }
+    }
+    return { count, latest };
+}
+function mailboxRecordSummary(value) {
+    for (const key of ["message", "summary", "notes", "resolution", "title", "description", "issue", "status"]) {
+        const field = value[key];
+        if (typeof field === "string" && field.trim()) {
+            return field.replace(/\s+/g, " ").trim();
+        }
+    }
+    return "";
+}
+function appendCollaborationEvidence(message, evidence) {
+    const base = message.trim();
+    if (!base || base.includes(evidence)) {
+        return base || evidence;
+    }
+    return `${base} · ${evidence}`;
+}
+function featureSpecTitle(spec) {
+    const title = spec.match(/^Title:\s*(.+)$/m)?.[1]?.trim();
+    return title || null;
+}
+function collaborationDialogueAction(type) {
+    if (type === "feature.created") {
+        return "mailbox created";
+    }
+    if (type === "actor.completed") {
+        return "implementation completed";
+    }
+    if (type === "critic.completed") {
+        return "review completed";
+    }
+    if (type === "critic.revision_requested") {
+        return "revision requested";
+    }
+    return humanizeCollaborationType(type);
+}
+function collaborationWaveAction(type) {
+    const action = type.replace(/^feature\.wave_/, "wave ");
+    return humanizeCollaborationType(action);
+}
+function collaborationFeatureStateAction(state) {
+    if (state === "approved") {
+        return "feature approved";
+    }
+    if (state === "revision_needed") {
+        return "revision pending";
+    }
+    return `feature ${humanizeFeatureState(state)}`;
+}
+function humanizeFeatureState(state) {
+    return state.replaceAll("_", " ");
+}
+function humanizeCollaborationType(type) {
+    return type.replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim();
+}

package/dist/core/config-errors.js

@@ -0,0 +1,14 @@
+import { ZodError } from "zod";
+export function formatConfigErrorMessage(error) {
+    if (error instanceof ZodError) {
+        return error.issues
+            .map((issue) => ({
+            message: issue.message,
+            path: issue.path.map(String).join(".") || "config"
+        }))
+            .sort((left, right) => left.path.localeCompare(right.path))
+            .map((issue) => `${issue.path}: ${issue.message}`)
+            .join("\n");
+    }
+    return error instanceof Error ? error.message : String(error);
+}