npm - @astrosheep/keiyaku - Versions diffs - 4.5.5 → 4.5.6 - Mend

@astrosheep/keiyaku 4.5.5 → 4.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md +15 -19
package/build/src/cli/commands/task-invoke.d.ts +2 -0
package/build/src/cli/commands/task-invoke.js +8 -2
package/build/src/cli/commands/task.js +21 -3
package/build/src/cli/invoke.js +1 -0
package/build/src/cli/render/task.js +25 -1
package/build/src/runtime/proc/windows-launch.exe +0 -0
package/build/src/task/compose-language.d.ts +43 -0
package/build/src/task/compose-language.js +321 -0
package/build/src/task/compose-parser.d.ts +31 -0
package/build/src/task/compose-parser.js +178 -0
package/build/src/task/compose.d.ts +28 -9
package/build/src/task/compose.js +125 -287
package/build/src/task/index.d.ts +4 -3
package/build/src/task/index.js +14 -3
package/build/src/task/operations.d.ts +6 -1
package/package.json +2 -2

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md CHANGED Viewed

@@ -70,30 +70,26 @@ Relations are explicit facts: `needs` orders work, `parent` groups it,
 ## Batch Create Or Modify
 Use `task compose -` to create and modify multiple Tasks in one planning
-document:
+document. Its input grammar is documented by the Task CLI owner:
 ```bash
 keiyaku task compose - <<'EOF'
 ns=feature
-+ Parent pri=0
++ Parent
+as = parent
+pri = 0
+body <<BODY
 Parent body.
-  + Child needs=@task/existing
-@task/existing pri=1 relates+=@task/other
-Replacement body.
+BODY
++ Child
+parent = ^parent
+needs = @task/existing
 EOF
 ```
-- Optional first line `ns=<segment/...>` selects the allocation namespace;
-  `ns=` selects root.
-- `+ <title>` creates a Task. `@task/<id>` modifies an existing Task.
-- Two spaces of indentation assign the preceding shallower Task as `parent`.
-- Inline assignments are `pri=`, `parent=`, `needs=`, `supersedes=`, and
-  `relates=`. Relation values are comma-separated `@task/...` references.
-- `=` replaces or clears a field. `+=` appends only to `needs`, `supersedes`,
-  or `relates`.
-- Prose after a node replaces its body; bare `body=` clears it. Prefix body
-  lines beginning with `+ `, `@task/`, or `\` with one `\`.
-Compose does not change Task lifecycle state. Each changed Task is admitted
-independently; an incomplete result returns a canonical draft for the remaining
-batch.
+Use `--plan` to inspect aliases, admission order, and body byte previews without
+writing. Compose does not change Task lifecycle state. Each changed Task is
+admitted independently; an incomplete result returns a reusable draft for the
+remaining batch.

package/build/src/cli/commands/task-invoke.d.ts CHANGED Viewed

@@ -19,6 +19,7 @@ export type TaskWorldObservation = Readonly<{
 }>;
 type TaskInput = Readonly<{
     world: WorldRoot | null;
+    candidate: WorldRoot | null;
     context: Readonly<{
         directory: string;
         boundary: string;
@@ -30,6 +31,7 @@ type TaskInput = Readonly<{
 export declare function invokeTaskFromEdge(input: Readonly<{
     parsed: ParsedTaskCommand;
     world: WorldRoot | null;
+    candidate: WorldRoot | null;
     context: Readonly<{
         directory: string;
         boundary: string;

package/build/src/cli/commands/task-invoke.js CHANGED Viewed

@@ -8,6 +8,7 @@ export async function invokeTaskFromEdge(input) {
     try {
         return await invokeTask(input.parsed, {
             world: input.world,
+            candidate: input.candidate,
             context: input.context,
             establish: input.establish,
             readStdin: input.readStdin,
@@ -293,6 +294,8 @@ function missingWorld(command) {
     });
     if (isWorldObservation(command))
         return { kind: "absent" };
+    if (command.action === "compose" && command.flags.plan === true)
+        return { kind: "absent" };
     if (command.action === "namespace")
         return { kind: "accepted", value: [] };
     if (command.action === "hold" || command.action === "done" || command.action === "drop") {
@@ -338,6 +341,7 @@ async function invokeLocalMutation(tasks, command, input, current) {
                 markdown: await input.readStdin(),
                 namespace: current ?? [],
                 ...(input.actor === undefined ? {} : { actor: input.actor }),
+                ...(command.flags.plan === true ? { plan: true } : {}),
             });
         default:
             throw new Error(`task action has no invocation: ${command.action}`);
@@ -345,17 +349,19 @@ async function invokeLocalMutation(tasks, command, input, current) {
 }
 function establishesWorld(command) {
     return (command.action === "add" ||
-        command.action === "compose" ||
+        (command.action === "compose" && command.flags.plan !== true) ||
         (command.action === "namespace" && command.positionals.length > 0));
 }
 function forwardsMutation(command) {
     return (command.action !== "show" &&
         command.action !== "tree" &&
         command.action !== "namespace" &&
+        !(command.action === "compose" && command.flags.plan === true) &&
         !isWorldObservation(command));
 }
 export async function invokeTask(command, input) {
-    const world = input.world ?? (establishesWorld(command) ? await input.establish() : null);
+    const planOnly = command.action === "compose" && command.flags.plan === true;
+    const world = input.world ?? (planOnly ? input.candidate : establishesWorld(command) ? await input.establish() : null);
     if (world === null)
         return missingWorld(command);
     const tasks = Tasks.of(world);

package/build/src/cli/commands/task.js CHANGED Viewed

@@ -133,9 +133,27 @@ task add [--namespace <ns>] [--actor <actor>] -`,
     compose: {
         arity: [0, 0],
         stdin: "compose",
-        flags: { ...COMMON, actor: "value" },
-        usage: "task compose [--actor <actor>] -",
-        purpose: "Admit Task documents independently; partial admission has no cross-file atomicity or rollback.",
+        flags: { ...COMMON, actor: "value", plan: "boolean" },
+        usage: "task compose [--actor <actor>] [--plan] -",
+        purpose: "Plan or admit one explicit Task composition.",
+        details: [
+            "nodes: + <Title> creates; @task/<id> modifies a pre-existing Task",
+            "properties: as = <alias>; pri = 0..3; parent = <ref>|empty",
+            "relations: needs|supersedes|relates with =, +=, or -=",
+            "references: @task/... is pre-existing; ^alias is new in this document",
+            "body: body = clears; body <<TOKEN reads exact content to TOKEN",
+            "TOKEN: [A-Z][A-Z0-9_]* with length 3..32",
+            "example:",
+            "  ns=feature",
+            "  + Parent",
+            "  as = parent",
+            "  pri = 1",
+            "  body <<BODY",
+            "  Exact body bytes.",
+            "  BODY",
+            "  + Child",
+            "  parent = ^parent",
+        ].join("\n"),
     },
 };
 export function isTaskAction(value) {

package/build/src/cli/invoke.js CHANGED Viewed

@@ -318,6 +318,7 @@ async function invokeParsed(invocation, runtime) {
         return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
             parsed,
             world,
+            candidate: candidateWorld,
             context: taskContext,
             establish: coordinates.establishWorld,
             readStdin: edge.readStdin,

package/build/src/cli/render/task.js CHANGED Viewed

@@ -59,6 +59,9 @@ function projectRefusal(refusal) {
     if (refusal.kind === "relation-owned-by-other") {
         return { line: `relation-owned-by-other ${refusal.taskId} ${refusal.related} ${refusal.declaringTask}` };
     }
+    if (refusal.kind === "invalid-composition") {
+        return { line: refusal.kind, compositionDiagnostics: refusal.diagnostics };
+    }
     return { line: refusal.kind, diagnostic: refusal.diagnostic };
 }
 function appendDiagnostic(lines, diagnostic) {
@@ -73,6 +76,9 @@ function renderFailure(verb, result, columns) {
     const facts = projectRefusal(result.refusal);
     lines.push(facts.line);
     appendDiagnostic(lines, facts.diagnostic);
+    for (const item of facts.compositionDiagnostics ?? []) {
+        lines.push(`line ${item.line} · ${safeText(item.reason)} · ${safeText(item.token)}`);
+    }
     return lines.join("\n");
 }
 function edge(label, ref, mark) {
@@ -256,12 +262,30 @@ function stoppedLines(stopped) {
     appendDiagnostic(lines, facts.diagnostic);
     return lines;
 }
+function aliasLines(aliases) {
+    return aliases.map((binding) => `alias ^${binding.alias} ${binding.taskId}`);
+}
+function renderPlan(result) {
+    const lines = [
+        `compose plan · ${result.admissionOrder.length} documents`,
+        ...aliasLines(result.aliases),
+        ...result.admissionOrder.map((id, index) => `admit ${index + 1} ${id}`),
+    ];
+    for (const body of result.bodies) {
+        lines.push(`body ${body.taskId} · ${body.bytes} bytes`);
+        lines.push(`  first ${safeText(body.firstLine)}`);
+        lines.push(`  last ${safeText(body.lastLine)}`);
+    }
+    return lines.join("\n");
+}
 function renderCompose(result, columns) {
     if (result.kind === "incomplete")
         return "";
+    if (result.kind === "planned")
+        return renderPlan(result);
     if (result.kind !== "accepted")
         return renderFailure("compose", result, columns);
-    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`];
+    const lines = [`✓ compose accepted · ${result.documentChanges.length} changed`, ...aliasLines(result.aliases)];
     composeDiffs(lines, result.documentChanges);
     return lines.join("\n");
 }

package/build/src/runtime/proc/windows-launch.exe CHANGED Viewed

Binary file

package/build/src/task/compose-language.d.ts ADDED Viewed

@@ -0,0 +1,43 @@
+import type { TaskBoard } from "./board.js";
+import { type TaskDocument } from "./document.js";
+import { type TaskId } from "./identity.js";
+import { type TaskCompositionDiagnostic } from "./operations.js";
+export type TaskCompositionAlias = Readonly<{
+    alias: string;
+    taskId: TaskId;
+}>;
+export type TaskCompositionBodyPreview = Readonly<{
+    taskId: TaskId;
+    bytes: number;
+    firstLine: string;
+    lastLine: string;
+}>;
+export type PlannedTask = Readonly<{
+    index: number;
+    line: number;
+    kind: "new" | "existing";
+    alias?: string;
+    before: TaskDocument | null;
+    after: TaskDocument;
+}>;
+export type TaskCompositionPlan = Readonly<{
+    namespace: readonly string[];
+    aliases: readonly TaskCompositionAlias[];
+    admissionOrder: readonly TaskId[];
+    bodies: readonly TaskCompositionBodyPreview[];
+    tasks: readonly PlannedTask[];
+}>;
+export type TaskCompositionPlanning = Readonly<{
+    kind: "planned";
+    plan: TaskCompositionPlan;
+}> | Readonly<{
+    kind: "refused";
+    diagnostics: readonly TaskCompositionDiagnostic[];
+}>;
+export declare function planTaskComposition(input: Readonly<{
+    markdown: string;
+    board: TaskBoard;
+    namespace: readonly string[];
+    at: string;
+    actor?: string;
+}>): TaskCompositionPlanning;

package/build/src/task/compose-language.js ADDED Viewed

@@ -0,0 +1,321 @@
+import { serializeTaskDocument } from "./document.js";
+import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
+import { parseTaskComposition } from "./compose-parser.js";
+import { advanceTaskTimestamp } from "./operations.js";
+function diagnostic(line, reason, token) {
+    return { line, reason, token };
+}
+function occupied(board, namespace) {
+    return new Set([...board.tasks.values()].flatMap((task) => {
+        const coordinate = parseTaskId(task.id);
+        return sameNamespace(coordinate.namespace, namespace) ? [coordinate.localId] : [];
+    }));
+}
+function createdTask(id, title, at, actor) {
+    return {
+        id,
+        title,
+        state: "open",
+        priority: 2,
+        needs: [],
+        parent: null,
+        supersedes: [],
+        relates: [],
+        note: "",
+        ...(actor === undefined ? {} : { createdBy: actor }),
+        createdAt: at,
+        updatedAt: at,
+        body: "",
+    };
+}
+function aliasFor(node) {
+    return node.assignments.find((item) => item.field === "as");
+}
+function allocateNodes(input, diagnostics) {
+    const ids = occupied(input.board, input.namespace);
+    const allocations = new Map();
+    for (const node of input.parsed.nodes) {
+        if (node.kind !== "new")
+            continue;
+        try {
+            const localId = allocateLocalId(deriveLocalStem(node.title), ids);
+            ids.add(localId);
+            const id = formatTaskId({ namespace: input.namespace, localId });
+            allocations.set(node.index, createdTask(id, node.title, input.at, input.actor));
+        }
+        catch (error) {
+            diagnostics.push(diagnostic(node.line, error instanceof Error ? error.message : String(error), node.title));
+        }
+    }
+    return allocations;
+}
+function collectAliases(nodes, allocations, diagnostics) {
+    const aliases = new Map();
+    for (const node of nodes) {
+        const declarations = node.assignments.filter((item) => item.field === "as");
+        for (const duplicate of declarations.slice(1)) {
+            diagnostics.push(diagnostic(duplicate.line, "alias is assigned more than once", duplicate.token));
+        }
+        const declaration = declarations[0];
+        if (declaration === undefined)
+            continue;
+        if (node.kind !== "new") {
+            diagnostics.push(diagnostic(declaration.line, "only a new task may declare an alias", declaration.token));
+            continue;
+        }
+        if (declaration.operator !== "=" || !/^[a-z0-9-]+$/u.test(declaration.value)) {
+            diagnostics.push(diagnostic(declaration.line, "alias must use as = [a-z0-9-]+", declaration.token));
+            continue;
+        }
+        if (aliases.has(declaration.value)) {
+            diagnostics.push(diagnostic(declaration.line, "alias must be unique in the composition", declaration.value));
+            continue;
+        }
+        const allocated = allocations.get(node.index);
+        if (allocated !== undefined)
+            aliases.set(declaration.value, allocated.id);
+    }
+    return aliases;
+}
+function resolveReference(raw, line, board, aliases, diagnostics) {
+    if (raw.startsWith("^")) {
+        const alias = raw.slice(1);
+        const resolved = aliases.get(alias);
+        if (resolved === undefined)
+            diagnostics.push(diagnostic(line, "new-task alias is not declared", raw));
+        return resolved;
+    }
+    if (!raw.startsWith("@task/")) {
+        diagnostics.push(diagnostic(line, "reference must be @task/... or ^alias", raw));
+        return undefined;
+    }
+    try {
+        const id = raw.slice(1);
+        parseTaskId(id);
+        if (!board.tasks.has(id))
+            diagnostics.push(diagnostic(line, "@ reference must name a pre-existing task", raw));
+        return board.tasks.has(id) ? id : undefined;
+    }
+    catch (error) {
+        diagnostics.push(diagnostic(line, error instanceof Error ? error.message : String(error), raw));
+        return undefined;
+    }
+}
+function referenceList(assignment, board, aliases, diagnostics) {
+    if (assignment.value === "")
+        return [];
+    const raw = assignment.value.split(",").map((item) => item.trim());
+    if (raw.some((item) => item.length === 0)) {
+        diagnostics.push(diagnostic(assignment.line, "reference list contains an empty item", assignment.token));
+        return undefined;
+    }
+    const resolved = raw.map((item) => resolveReference(item, assignment.line, board, aliases, diagnostics));
+    if (resolved.some((item) => item === undefined))
+        return undefined;
+    const ids = resolved;
+    if (new Set(ids).size !== ids.length) {
+        diagnostics.push(diagnostic(assignment.line, "reference list contains a duplicate", assignment.token));
+        return undefined;
+    }
+    return ids;
+}
+function patchRelation(current, assignment, values, diagnostics) {
+    if (assignment.operator === "=")
+        return values;
+    if (assignment.operator === "+=")
+        return [...current, ...values.filter((id) => !current.includes(id))];
+    const missing = values.filter((id) => !current.includes(id));
+    for (const id of missing)
+        diagnostics.push(diagnostic(assignment.line, "cannot remove an absent relation", `@${id}`));
+    return missing.length === 0 ? current.filter((id) => !values.includes(id)) : current;
+}
+function applyAssignments(node, base, board, aliases, diagnostics) {
+    let next = base;
+    const scalar = new Set();
+    for (const assignment of node.assignments) {
+        if (assignment.field === "as")
+            continue;
+        if (assignment.field === "pri" || assignment.field === "parent") {
+            if (scalar.has(assignment.field)) {
+                diagnostics.push(diagnostic(assignment.line, `${assignment.field} is assigned more than once`, assignment.token));
+            }
+            scalar.add(assignment.field);
+        }
+        if (assignment.field === "pri") {
+            if (assignment.operator !== "=" || !/^[0-3]$/u.test(assignment.value)) {
+                diagnostics.push(diagnostic(assignment.line, "pri must use = with a value from 0 through 3", assignment.token));
+            }
+            else
+                next = { ...next, priority: Number(assignment.value) };
+            continue;
+        }
+        if (assignment.field === "parent") {
+            if (assignment.operator !== "=") {
+                diagnostics.push(diagnostic(assignment.line, "parent accepts only =", assignment.token));
+            }
+            else if (assignment.value === "")
+                next = { ...next, parent: null };
+            else {
+                const id = resolveReference(assignment.value.trim(), assignment.line, board, aliases, diagnostics);
+                if (id !== undefined)
+                    next = { ...next, parent: id };
+            }
+            continue;
+        }
+        const values = referenceList(assignment, board, aliases, diagnostics);
+        if (values === undefined)
+            continue;
+        if (assignment.operator !== "=" && values.length === 0) {
+            diagnostics.push(diagnostic(assignment.line, `${assignment.operator} requires at least one reference`, assignment.token));
+            continue;
+        }
+        next = { ...next, [assignment.field]: patchRelation(next[assignment.field], assignment, values, diagnostics) };
+    }
+    if (node.body !== undefined)
+        next = { ...next, body: node.body.value };
+    for (const field of ["needs", "supersedes", "relates"]) {
+        if (next[field].includes(next.id))
+            diagnostics.push(diagnostic(node.line, `${field} cannot reference the task itself`, next.id));
+    }
+    if (next.parent === next.id)
+        diagnostics.push(diagnostic(node.line, "parent cannot reference the task itself", next.id));
+    return next;
+}
+function relationTargets(document, relation) {
+    return relation === "needs" ? document.needs : document.parent === null ? [] : [document.parent];
+}
+function pathExists(board, start, goal, relation) {
+    const seen = new Set();
+    const pending = [start];
+    while (pending.length > 0) {
+        const id = pending.pop();
+        if (id === goal)
+            return true;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const task = board.tasks.get(id);
+        if (task !== undefined)
+            pending.push(...relationTargets(task, relation));
+    }
+    return false;
+}
+function diagnoseIntroducedCycles(after, tasks, diagnostics) {
+    for (const task of tasks) {
+        for (const relation of ["needs", "parent"]) {
+            const old = task.before === null ? [] : relationTargets(task.before, relation);
+            for (const target of relationTargets(task.after, relation)) {
+                if (!old.includes(target) && pathExists(after, target, task.after.id, relation)) {
+                    diagnostics.push(diagnostic(task.line, `${relation} edge creates a cycle`, `${task.after.id} -> ${target}`));
+                }
+            }
+        }
+    }
+}
+function changed(task) {
+    return (task.before === null ||
+        !Buffer.from(serializeTaskDocument(task.before)).equals(Buffer.from(serializeTaskDocument(task.after))));
+}
+function stableAdmissionOrder(tasks, diagnostics) {
+    const candidates = tasks.filter(changed);
+    const byId = new Map(candidates.map((task) => [task.after.id, task]));
+    const dependencies = new Map(candidates.map((task) => [task.after.id, new Set()]));
+    for (const task of candidates) {
+        const targets = [...task.after.needs, ...(task.after.parent === null ? [] : [task.after.parent])];
+        for (const target of targets) {
+            const plannedTarget = byId.get(target);
+            if (plannedTarget?.before === null)
+                dependencies.get(task.after.id).add(target);
+        }
+    }
+    const remaining = new Set(candidates.map((task) => task.after.id));
+    const ordered = [];
+    while (remaining.size > 0) {
+        const ready = candidates.find((task) => remaining.has(task.after.id) && [...dependencies.get(task.after.id)].every((id) => !remaining.has(id)));
+        if (ready === undefined) {
+            const first = candidates.find((task) => remaining.has(task.after.id));
+            diagnostics.push(diagnostic(first.line, "needs and parent references create an admission cycle", first.after.id));
+            return [];
+        }
+        remaining.delete(ready.after.id);
+        ordered.push(ready);
+    }
+    return ordered;
+}
+function bodyPreview(node, id) {
+    if (node.body?.kind !== "replace")
+        return null;
+    const lines = node.body.value.split(/\r\n|\n|\r/u);
+    return {
+        taskId: id,
+        bytes: Buffer.byteLength(node.body.value),
+        firstLine: lines[0] ?? "",
+        lastLine: lines.at(-1) ?? "",
+    };
+}
+export function planTaskComposition(input) {
+    const parsed = parseTaskComposition(input.markdown);
+    const diagnostics = [...parsed.diagnostics];
+    const namespace = parsed.namespace ?? input.namespace;
+    const allocationInput = {
+        parsed,
+        board: input.board,
+        namespace,
+        at: input.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    };
+    const allocations = allocateNodes(allocationInput, diagnostics);
+    const aliases = collectAliases(parsed.nodes, allocations, diagnostics);
+    const addressed = new Set();
+    const tasks = [];
+    for (const node of parsed.nodes) {
+        const before = node.kind === "new" ? null : (input.board.tasks.get(node.id) ?? null);
+        const base = node.kind === "new" ? allocations.get(node.index) : before;
+        if (base === null || base === undefined) {
+            diagnostics.push(diagnostic(node.line, "existing task does not exist before composition", `@${node.id}`));
+            continue;
+        }
+        if (addressed.has(base.id)) {
+            diagnostics.push(diagnostic(node.line, "task is addressed more than once", base.id));
+            continue;
+        }
+        addressed.add(base.id);
+        let after = applyAssignments(node, base, input.board, aliases, diagnostics);
+        if (before !== null && changed({ index: node.index, line: node.line, kind: node.kind, before, after })) {
+            after = { ...after, updatedAt: advanceTaskTimestamp(before.updatedAt, input.at) };
+        }
+        tasks.push({
+            index: node.index,
+            line: node.line,
+            kind: node.kind,
+            ...(aliasFor(node) === undefined ? {} : { alias: aliasFor(node).value }),
+            before,
+            after,
+        });
+    }
+    const post = new Map(input.board.tasks);
+    for (const task of tasks)
+        post.set(task.after.id, task.after);
+    diagnoseIntroducedCycles({ tasks: post }, tasks, diagnostics);
+    const ordered = stableAdmissionOrder(tasks, diagnostics);
+    if (diagnostics.length > 0)
+        return { kind: "refused", diagnostics };
+    const aliasBindings = [...aliases].map(([alias, taskId]) => ({ alias, taskId }));
+    const bodies = parsed.nodes.flatMap((node) => {
+        const task = tasks.find((candidate) => candidate.index === node.index);
+        if (task === undefined)
+            return [];
+        const preview = bodyPreview(node, task.after.id);
+        return preview === null ? [] : [preview];
+    });
+    return {
+        kind: "planned",
+        plan: {
+            namespace,
+            aliases: aliasBindings,
+            admissionOrder: ordered.map((task) => task.after.id),
+            bodies,
+            tasks: ordered,
+        },
+    };
+}

package/build/src/task/compose-parser.d.ts ADDED Viewed

@@ -0,0 +1,31 @@
+import { type TaskId } from "./identity.js";
+import type { TaskCompositionDiagnostic } from "./operations.js";
+export type RelationField = "needs" | "supersedes" | "relates";
+export type Assignment = Readonly<{
+    field: "as" | "parent" | "pri" | RelationField;
+    operator: "=" | "+=" | "-=";
+    value: string;
+    line: number;
+    token: string;
+}>;
+export type BodyAssignment = Readonly<{
+    kind: "clear" | "replace";
+    value: string;
+    line: number;
+    token: string;
+}>;
+export type ParsedNode = Readonly<{
+    index: number;
+    line: number;
+    kind: "new" | "existing";
+    title?: string;
+    id?: TaskId;
+    assignments: readonly Assignment[];
+    body?: BodyAssignment;
+}>;
+export type ParsedComposition = Readonly<{
+    namespace?: readonly string[];
+    nodes: readonly ParsedNode[];
+    diagnostics: readonly TaskCompositionDiagnostic[];
+}>;
+export declare function parseTaskComposition(source: string): ParsedComposition;