@workflow-cannon/workspace-kit 0.6.0 → 0.8.0

package/dist/modules/task-engine/index.js

@@ -1,16 +1,11 @@
-import path from "node:path";
-import fs from "node:fs/promises";
+import { maybeSpawnTranscriptHookAfterCompletion } from "../../core/transcript-completion-hook.js";
 import { TaskStore } from "./store.js";
 import { TransitionService } from "./service.js";
 import { TaskEngineError } from "./transitions.js";
-import { generateTasksMd } from "./generator.js";
-import { importTasksFromMarkdown } from "./importer.js";
 import { getNextActions } from "./suggestions.js";
 export { TaskStore } from "./store.js";
 export { TransitionService } from "./service.js";
 export { TaskEngineError, TransitionValidator, isTransitionAllowed, getTransitionAction, resolveTargetState, getAllowedTransitionsFrom, stateValidityGuard, dependencyCheckGuard } from "./transitions.js";
-export { generateTasksMd } from "./generator.js";
-export { importTasksFromMarkdown } from "./importer.js";
 export { getNextActions } from "./suggestions.js";
 function taskStorePath(ctx) {
     const tasks = ctx.effectiveConfig?.tasks;
@@ -61,16 +56,6 @@ export const taskEngineModule = {
                     file: "get-ready-queue.md",
                     description: "Get ready tasks sorted by priority."
                 },
-                {
-                    name: "import-tasks",
-                    file: "import-tasks.md",
-                    description: "One-time import from TASKS.md into engine state."
-                },
-                {
-                    name: "generate-tasks-md",
-                    file: "generate-tasks-md.md",
-                    description: "Generate read-only TASKS.md from engine state."
-                },
                 {
                     name: "get-next-actions",
                     file: "get-next-actions.md",
@@ -113,6 +98,9 @@ export const taskEngineModule = {
             try {
                 const service = new TransitionService(store);
                 const result = await service.runTransition({ taskId, action, actor });
+                if (result.evidence.toState === "completed") {
+                    maybeSpawnTranscriptHookAfterCompletion(ctx.workspacePath, (ctx.effectiveConfig ?? {}));
+                }
                 return {
                     ok: true,
                     code: "transition-applied",
@@ -190,60 +178,6 @@ export const taskEngineModule = {
                 data: { tasks: ready, count: ready.length }
             };
         }
-        if (command.name === "import-tasks") {
-            const sourcePath = typeof args.sourcePath === "string"
-                ? path.resolve(ctx.workspacePath, args.sourcePath)
-                : path.resolve(ctx.workspacePath, "docs/maintainers/TASKS.md");
-            try {
-                const result = await importTasksFromMarkdown(sourcePath);
-                store.replaceAllTasks(result.tasks);
-                await store.save();
-                return {
-                    ok: true,
-                    code: "tasks-imported",
-                    message: `Imported ${result.imported} tasks (${result.skipped} skipped)`,
-                    data: {
-                        imported: result.imported,
-                        skipped: result.skipped,
-                        errors: result.errors
-                    }
-                };
-            }
-            catch (err) {
-                if (err instanceof TaskEngineError) {
-                    return { ok: false, code: err.code, message: err.message };
-                }
-                return {
-                    ok: false,
-                    code: "import-parse-error",
-                    message: err.message
-                };
-            }
-        }
-        if (command.name === "generate-tasks-md") {
-            const outputPath = typeof args.outputPath === "string"
-                ? path.resolve(ctx.workspacePath, args.outputPath)
-                : path.resolve(ctx.workspacePath, "docs/maintainers/TASKS.md");
-            const tasks = store.getAllTasks();
-            const markdown = generateTasksMd(tasks);
-            try {
-                await fs.mkdir(path.dirname(outputPath), { recursive: true });
-                await fs.writeFile(outputPath, markdown, "utf8");
-            }
-            catch (err) {
-                return {
-                    ok: false,
-                    code: "storage-write-error",
-                    message: `Failed to write TASKS.md: ${err.message}`
-                };
-            }
-            return {
-                ok: true,
-                code: "tasks-md-generated",
-                message: `Generated TASKS.md with ${tasks.length} tasks`,
-                data: { outputPath, taskCount: tasks.length }
-            };
-        }
         if (command.name === "get-next-actions") {
             const tasks = store.getAllTasks();
             const suggestion = getNextActions(tasks);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",
@@ -30,7 +30,11 @@
     "check-release-channel": "node scripts/check-release-channel.mjs",
     "generate-runtime-diagnostics": "node scripts/generate-runtime-diagnostics.mjs",
     "prune-evidence": "node scripts/prune-evidence.mjs",
-    "phase4-gates": "pnpm run check-compatibility && pnpm run check-planning-consistency && pnpm run check-release-channel"
+    "phase4-gates": "pnpm run check-compatibility && pnpm run check-planning-consistency && pnpm run check-release-channel",
+    "phase5-gates": "pnpm run phase4-gates && pnpm run test",
+    "pre-release-transcript-hook": "pnpm run build && node scripts/pre-release-transcript-hook.mjs",
+    "transcript:sync": "node scripts/run-transcript-cli.mjs sync-transcripts",
+    "transcript:ingest": "node scripts/run-transcript-cli.mjs ingest-transcripts"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",

package/dist/modules/task-engine/generator.d.ts

@@ -1,2 +0,0 @@
-import type { TaskEntity } from "./types.js";
-export declare function generateTasksMd(tasks: TaskEntity[]): string;

package/dist/modules/task-engine/generator.js

@@ -1,101 +0,0 @@
-const STATUS_MARKERS = {
-    proposed: "[p]",
-    ready: "[ ]",
-    in_progress: "[~]",
-    blocked: "[!]",
-    completed: "[x]",
-    cancelled: "[-]"
-};
-function groupByPhase(tasks) {
-    const groups = new Map();
-    for (const task of tasks) {
-        const phase = task.phase ?? "Uncategorized";
-        const group = groups.get(phase) ?? [];
-        group.push(task);
-        groups.set(phase, group);
-    }
-    return groups;
-}
-function buildReadyQueueLine(tasks) {
-    const ready = tasks
-        .filter((t) => t.status === "ready")
-        .sort((a, b) => {
-        const pa = a.priority ?? "P9";
-        const pb = b.priority ?? "P9";
-        return pa.localeCompare(pb);
-    });
-    if (ready.length === 0)
-        return "- Ready queue: _(empty)_";
-    return `- Ready queue: ${ready.map((t) => `\`${t.id}\``).join(", ")}`;
-}
-function buildCurrentPhase(tasks) {
-    const inProgress = tasks.filter((t) => t.status === "in_progress");
-    const ready = tasks.filter((t) => t.status === "ready");
-    const active = [...inProgress, ...ready];
-    if (active.length === 0)
-        return "- Current phase in execution: _(no active tasks)_";
-    const phases = [...new Set(active.map((t) => t.phase).filter(Boolean))];
-    if (phases.length === 0)
-        return "- Current phase in execution: _(unknown)_";
-    return `- Current phase in execution: _${phases[0]}_`;
-}
-function renderTask(task) {
-    const marker = STATUS_MARKERS[task.status] ?? "[ ]";
-    const lines = [];
-    lines.push(`### ${marker} ${task.id} ${task.title}`);
-    if (task.priority) {
-        lines.push(`- Priority: ${task.priority}`);
-    }
-    if (task.approach) {
-        lines.push(`- Approach: ${task.approach}`);
-    }
-    const deps = task.dependsOn ?? [];
-    lines.push(`- Depends on: ${deps.length > 0 ? deps.map((d) => `\`${d}\``).join(", ") : "none"}`);
-    const unblocks = task.unblocks ?? [];
-    if (unblocks.length > 0) {
-        lines.push(`- Unblocks: ${unblocks.map((u) => `\`${u}\``).join(", ")}`);
-    }
-    if (task.technicalScope && task.technicalScope.length > 0) {
-        lines.push("- Technical scope:");
-        for (const item of task.technicalScope) {
-            lines.push(`  - ${item}`);
-        }
-    }
-    if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
-        lines.push("- Acceptance criteria:");
-        for (const item of task.acceptanceCriteria) {
-            lines.push(`  - ${item}`);
-        }
-    }
-    return lines.join("\n");
-}
-export function generateTasksMd(tasks) {
-    const lines = [];
-    lines.push("# Workflow Cannon Tasks");
-    lines.push("");
-    lines.push("> This file is generated by the Task Engine. Do not edit manually.");
-    lines.push("");
-    lines.push("Status markers:");
-    lines.push("- `[p]` proposed");
-    lines.push("- `[ ]` ready");
-    lines.push("- `[~]` in progress");
-    lines.push("- `[!]` blocked");
-    lines.push("- `[x]` completed");
-    lines.push("- `[-]` cancelled");
-    lines.push("");
-    lines.push("## Current execution state");
-    lines.push("");
-    lines.push(buildCurrentPhase(tasks));
-    lines.push(buildReadyQueueLine(tasks));
-    lines.push("");
-    const phaseGroups = groupByPhase(tasks);
-    for (const [phase, phaseTasks] of phaseGroups) {
-        lines.push(`## ${phase}`);
-        lines.push("");
-        for (const task of phaseTasks) {
-            lines.push(renderTask(task));
-            lines.push("");
-        }
-    }
-    return lines.join("\n");
-}

package/dist/modules/task-engine/importer.d.ts

@@ -1,8 +0,0 @@
-import type { TaskEntity } from "./types.js";
-export type ImportResult = {
-    imported: number;
-    skipped: number;
-    errors: string[];
-    tasks: TaskEntity[];
-};
-export declare function importTasksFromMarkdown(sourcePath: string): Promise<ImportResult>;

package/dist/modules/task-engine/importer.js

@@ -1,157 +0,0 @@
-import fs from "node:fs/promises";
-import { TaskEngineError } from "./transitions.js";
-const STATUS_MAP = {
-    "[p]": "proposed",
-    "[ ]": "ready",
-    "[~]": "in_progress",
-    "[!]": "blocked",
-    "[x]": "completed",
-    "[-]": "cancelled"
-};
-function parseTaskId(heading) {
-    const match = heading.match(/^###\s+\[[^\]]*\]\s+(T\d+)/);
-    return match?.[1] ?? null;
-}
-function parseStatus(heading) {
-    for (const [marker, status] of Object.entries(STATUS_MAP)) {
-        if (heading.includes(marker))
-            return status;
-    }
-    return "ready";
-}
-function parseTitle(heading) {
-    const match = heading.match(/^###\s+\[[^\]]*\]\s+T\d+\s+(.+)/);
-    return match?.[1]?.trim() ?? "Untitled";
-}
-function extractField(lines, prefix) {
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith(prefix)) {
-            return trimmed.slice(prefix.length).trim();
-        }
-    }
-    return undefined;
-}
-function extractListField(lines, fieldPrefix) {
-    const items = [];
-    let capturing = false;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith(fieldPrefix)) {
-            capturing = true;
-            continue;
-        }
-        if (capturing) {
-            if (/^\s{2,}-\s/.test(line)) {
-                items.push(line.replace(/^\s*-\s*/, "").trim());
-                continue;
-            }
-            if (trimmed.startsWith("- ")) {
-                capturing = false;
-                continue;
-            }
-            if (trimmed === "") {
-                continue;
-            }
-        }
-    }
-    return items;
-}
-function parseTaskIds(text) {
-    if (!text || text.trim() === "none")
-        return [];
-    const ids = [];
-    const matches = text.matchAll(/`?(T\d+)`?/g);
-    for (const m of matches) {
-        ids.push(m[1]);
-    }
-    return ids;
-}
-function parsePriority(text) {
-    if (!text)
-        return undefined;
-    const match = text.match(/(P[123])/);
-    return match?.[1];
-}
-function parsePhase(sectionHeading) {
-    const match = sectionHeading.match(/^##\s+(.+)/);
-    return match?.[1]?.trim();
-}
-export async function importTasksFromMarkdown(sourcePath) {
-    let content;
-    try {
-        content = await fs.readFile(sourcePath, "utf8");
-    }
-    catch (err) {
-        throw new TaskEngineError("import-parse-error", `Failed to read TASKS.md: ${err.message}`);
-    }
-    const lines = content.split("\n");
-    const tasks = [];
-    const errors = [];
-    let skipped = 0;
-    let currentPhase;
-    const now = new Date().toISOString();
-    let taskStartIdx = -1;
-    let taskLines = [];
-    function flushTask() {
-        if (taskStartIdx === -1 || taskLines.length === 0)
-            return;
-        const heading = taskLines[0];
-        const id = parseTaskId(heading);
-        if (!id) {
-            errors.push(`Line ${taskStartIdx + 1}: Could not parse task ID from heading`);
-            skipped++;
-            return;
-        }
-        const status = parseStatus(heading);
-        const title = parseTitle(heading);
-        const priorityStr = extractField(taskLines, "- Priority:");
-        const approach = extractField(taskLines, "- Approach:");
-        const dependsOnStr = extractField(taskLines, "- Depends on:");
-        const unblocksStr = extractField(taskLines, "- Unblocks:");
-        const technicalScope = extractListField(taskLines, "- Technical scope:");
-        const acceptanceCriteria = extractListField(taskLines, "- Acceptance criteria:");
-        const task = {
-            id,
-            status,
-            type: "workspace-kit",
-            title,
-            createdAt: now,
-            updatedAt: now,
-            priority: parsePriority(priorityStr),
-            dependsOn: parseTaskIds(dependsOnStr ?? ""),
-            unblocks: parseTaskIds(unblocksStr ?? ""),
-            phase: currentPhase,
-            approach: approach || undefined,
-            technicalScope: technicalScope.length > 0 ? technicalScope : undefined,
-            acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : undefined
-        };
-        tasks.push(task);
-    }
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (line.startsWith("## ") && !line.startsWith("### ")) {
-            flushTask();
-            taskStartIdx = -1;
-            taskLines = [];
-            currentPhase = parsePhase(line);
-            continue;
-        }
-        if (line.startsWith("### ")) {
-            flushTask();
-            taskStartIdx = i;
-            taskLines = [line];
-            continue;
-        }
-        if (taskStartIdx !== -1) {
-            taskLines.push(line);
-        }
-    }
-    flushTask();
-    return {
-        imported: tasks.length,
-        skipped,
-        errors,
-        tasks
-    };
-}