@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/cli/render/task.d.ts

@@ -1,41 +0,0 @@
-import type { BlockedTaskList, TaskBatchResult, TaskCompositionResult, TaskContextResult, TaskDecompositionTree, TaskDetail, TaskDoctorReport, TaskList, TaskMutationResult, TaskQueryResult, TaskUpdateResult } from "../../task/index.js";
-import { type TextRenderContext } from "./terminal.js";
-export { taskMark } from "./marks.js";
-type TaskListOutcome = TaskList | BlockedTaskList | TaskQueryResult;
-/** One addressed show selection: native details, or a refusal naming a missing addressed read. */
-export type TaskShowResult = TaskDetail | TaskDetail[] | Extract<TaskMutationResult, {
-    kind: "refused";
-}>;
-/** Presentation-only list scope the leaf acquired; never part of a product value. */
-export type TaskListScope = "world" | "current" | Readonly<{
-    namespace: string;
-}>;
-/** The union of native Task SDK answers one leaf renders directly; the CLI adds no result envelope. */
-type TaskNativeResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskShowResult | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskContextResult;
-type TaskFailure = Extract<TaskMutationResult, {
-    kind: "refused" | "retry";
-}> | Extract<TaskContextResult, {
-    kind: "refused" | "retry";
-}> | Extract<TaskCompositionResult, {
-    kind: "refused";
-}>;
-/** Task dispositions and relation states are snake_case facts; people read them as words. */
-export declare function dispositionText(word: string): string;
-export declare function taskFrameHead(view: string, scope: string): string;
-export declare function renderDoctor(report: TaskDoctorReport): string;
-/** One addressed show selection rendered directly from its native answer. */
-export declare function renderTaskShow(result: TaskShowResult, context?: TextRenderContext): string;
-/** One list read rendered from its native answer and the leaf's presentation-only scope. */
-export declare function renderTaskList(action: "ls" | "ready" | "blocked" | "query", scope: TaskListScope, result: TaskListOutcome, context?: TextRenderContext): string;
-export declare function renderTaskTree(result: TaskDecompositionTree, context?: TextRenderContext): string;
-export declare function renderTaskContext(result: TaskContextResult, context?: TextRenderContext): string;
-export declare function renderTaskCompose(result: TaskCompositionResult, context?: TextRenderContext): string;
-/** One single-Task mutation answer; `verb` is the literal action the leaf invoked. */
-export declare function renderTaskMutation(verb: string, result: TaskMutationResult, context?: TextRenderContext): string;
-export declare function renderTaskUpdate(result: TaskUpdateResult, context?: TextRenderContext): string;
-/** One lifecycle answer: a single mutation or a plural batch, both native shapes. */
-export declare function renderTaskLifecycle(verb: string, result: TaskMutationResult | TaskBatchResult, context?: TextRenderContext): string;
-/** A native refusal the CLI edge raised for one action, through the shared refusal grammar. */
-export declare function renderTaskFailure(verb: string, result: TaskFailure, context?: TextRenderContext): string;
-export declare function renderTaskIncompleteDiagnostic(result: TaskCompositionResult): string;
-export declare function taskExitCode(result: TaskNativeResult): number;

package/build/src/dispatch/association.d.ts

@@ -1 +0,0 @@
-export { dispatchAssociationSchema, NO_DISPATCH_ASSOCIATION, parseDispatchAssociation, type DispatchAssociation, } from "../akuma/dispatch-association.js";

package/build/src/dispatch/association.js

@@ -1 +0,0 @@
-export { dispatchAssociationSchema, NO_DISPATCH_ASSOCIATION, parseDispatchAssociation, } from "../akuma/dispatch-association.js";

package/build/src/task/board.d.ts

@@ -1,168 +0,0 @@
-import { type TaskDocument, type TaskPriority, type TaskState } from "./document.js";
-import { type TaskId } from "./identity.js";
-import { z } from "zod";
-import { type BoundedList } from "../bounded-list.js";
-export type TaskRef = Readonly<{
-    id: TaskId;
-    title: string | null;
-    state: TaskState | "missing";
-}>;
-export declare const taskRowSchema: z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    title: z.ZodString;
-    state: z.ZodEnum<{
-        open: "open";
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-    }>;
-    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-    disposition: z.ZodEnum<{
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-        ready: "ready";
-        blocked: "blocked";
-    }>;
-    updatedAt: z.ZodString;
-    bodyPresent: z.ZodBoolean;
-    children: z.ZodOptional<z.ZodObject<{
-        live: z.ZodNumber;
-        total: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export declare const taskRowsSchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-    id: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
-    title: z.ZodString;
-    state: z.ZodEnum<{
-        open: "open";
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-    }>;
-    priority: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
-    disposition: z.ZodEnum<{
-        in_progress: "in_progress";
-        on_hold: "on_hold";
-        done: "done";
-        drop: "drop";
-        ready: "ready";
-        blocked: "blocked";
-    }>;
-    updatedAt: z.ZodString;
-    bodyPresent: z.ZodBoolean;
-    children: z.ZodOptional<z.ZodObject<{
-        live: z.ZodNumber;
-        total: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>>>;
-export type TaskDisposition = z.infer<typeof taskRowSchema>["disposition"];
-export type TaskRow = z.infer<typeof taskRowSchema>;
-export type BlockedTaskRow = TaskRow & Readonly<{
-    blockers: readonly TaskRef[];
-}>;
-export type TaskDetailFacts = Readonly<{
-    task: TaskDocument;
-    needs: readonly (TaskRef & Readonly<{
-        released: boolean;
-    }>)[];
-    blockers: readonly TaskRef[];
-    blocks: readonly TaskRef[];
-    parent: TaskRef | null;
-    children: readonly TaskRef[];
-    supersedes: readonly TaskRef[];
-    supersededBy: readonly TaskRef[];
-    related: readonly TaskRef[];
-}>;
-export type TaskTreeNode = Readonly<{
-    task: TaskRef & Readonly<{
-        priority: TaskPriority | null;
-    }>;
-    cycle?: true;
-    children: readonly TaskTreeNode[];
-}>;
-export type TaskBoard = Readonly<{
-    tasks: ReadonlyMap<TaskId, TaskDocument>;
-}>;
-/** The local ids occupied across one namespace of the current board. */
-export declare function occupiedLocalIds(board: TaskBoard, namespace: readonly string[]): Set<string>;
-type TaskRelation = "needs" | "parent" | "supersedes" | "relates";
-export type TaskDoctorIssue = Readonly<{
-    kind: "missing-target";
-    taskId: TaskId;
-    relation: TaskRelation;
-    target: TaskId;
-}> | Readonly<{
-    kind: "self-relation";
-    taskId: TaskId;
-    relation: TaskRelation;
-}> | Readonly<{
-    kind: "cycle";
-    relation: "needs" | "parent" | "supersedes";
-    tasks: readonly TaskId[];
-}>;
-export declare function taskRef(board: TaskBoard, id: TaskId): TaskRef;
-export type TaskRelationProjection = Readonly<{
-    children(id: TaskId): readonly TaskRef[];
-    blocks(id: TaskId): readonly TaskRef[];
-    supersededBy(id: TaskId): readonly TaskRef[];
-    related(id: TaskId): readonly TaskRef[];
-}>;
-export declare function createTaskRelations(board: TaskBoard): TaskRelationProjection;
-export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
-export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
-export declare function projectOwnedDetailFacts(board: TaskBoard, id: TaskId): TaskDetailFacts | null;
-export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
-export declare function projectTaskRow(board: TaskBoard, relations: TaskRelationProjection, task: TaskDocument): TaskRow;
-export declare function projectRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
-/**
- * Rows for the identities that created work, grouped by creator. Only documents a
- * requested identity created reach row projection, and each group keeps the
- * established row order.
- */
-export declare function projectCreatedByRows(board: TaskBoard, relations: TaskRelationProjection, createdByIds: readonly string[]): ReadonlyMap<string, readonly TaskRow[]>;
-export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
-export declare function projectStatusRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null): ({
-    id: `task/${string}`;
-    title: string;
-    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-    priority: 0 | 1 | 2 | 3;
-    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
-    updatedAt: string;
-    bodyPresent: boolean;
-    children?: {
-        live: number;
-        total: number;
-    } | undefined;
-} | {
-    blockers: readonly Readonly<{
-        id: TaskId;
-        title: string | null;
-        state: TaskState | "missing";
-    }>[];
-    id: `task/${string}`;
-    title: string;
-    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
-    priority: 0 | 1 | 2 | 3;
-    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
-    updatedAt: string;
-    bodyPresent: boolean;
-    children?: {
-        live: number;
-        total: number;
-    } | undefined;
-})[];
-export type TaskBoardObservation = Readonly<{
-    statusRows: ReturnType<typeof projectStatusRows>;
-    selectRecentStatus(limit?: number): BoundedList<ReturnType<typeof projectStatusRows>[number]>;
-    selectNamespace(namespace: readonly string[]): readonly TaskRow[];
-    selectCreatedBy(createdBy: string): readonly TaskRow[];
-}>;
-export declare function projectTaskBoardObservation(board: TaskBoard): TaskBoardObservation;
-export declare function relationProblem(board: TaskBoard, before: TaskDocument | null, after: TaskDocument): string | null;
-export declare function diagnoseBoard(board: TaskBoard): readonly TaskDoctorIssue[];
-export declare function buildTree(board: TaskBoard, root: TaskId, relations: TaskRelationProjection): TaskTreeNode | null;
-export {};

package/build/src/task/catalog.d.ts

@@ -1,11 +0,0 @@
-import type { BoundedList } from "../bounded-list.js";
-import type { TaskRef, TaskRow } from "./board.js";
-import type { WorldRoot } from "../world.js";
-export declare function parseTaskNamespaceSelector(value: string): readonly string[];
-export type RecentTaskStatusRow = TaskRow & Readonly<{
-    blockers?: readonly TaskRef[];
-}>;
-export declare function observeRecentTaskStatus(world: WorldRoot, input?: Readonly<{
-    namespace?: readonly string[];
-    limit?: number;
-}>): Promise<BoundedList<RecentTaskStatusRow>>;

package/build/src/task/catalog.js

@@ -1,59 +0,0 @@
-import { isTaskSegment, parseTaskId } from "./identity.js";
-import { readRecentTaskDocuments, readTaskDocument } from "./store.js";
-export function parseTaskNamespaceSelector(value) {
-    if (value === "task/")
-        return [];
-    if (!value.startsWith("task/") || !value.endsWith("/")) {
-        throw new TypeError(`invalid Task namespace selector: ${value}`);
-    }
-    const body = value.slice("task/".length, -1);
-    const segments = body.split("/");
-    if (body.length === 0 || !segments.every(isTaskSegment)) {
-        throw new TypeError(`invalid Task namespace selector: ${value}`);
-    }
-    return parseTaskId(`task/${body}/placeholder`).namespace;
-}
-function terminal(task) {
-    return task?.state === "done" || task?.state === "drop";
-}
-async function catalogRow(world, task, documents) {
-    const needs = await Promise.all(task.needs.map(async (id) => documents.get(id) ?? (await readTaskDocument(world, id))));
-    const blockers = [];
-    if (task.state === "open" || task.state === "in_progress") {
-        for (const [index, need] of needs.entries()) {
-            if (terminal(need))
-                continue;
-            blockers.push({ id: task.needs[index], title: need?.title ?? null, state: need?.state ?? "missing" });
-        }
-    }
-    return {
-        id: task.id,
-        title: task.title,
-        state: task.state,
-        priority: task.priority,
-        disposition: task.state === "open" && needs.some((need) => !terminal(need))
-            ? "blocked"
-            : task.state === "open"
-                ? "ready"
-                : task.state,
-        updatedAt: task.updatedAt,
-        bodyPresent: task.body.length > 0,
-        ...(blockers.length === 0 ? {} : { blockers }),
-    };
-}
-export async function observeRecentTaskStatus(world, input = {}) {
-    const { namespace } = input;
-    if (namespace !== undefined && !namespace.every(isTaskSegment)) {
-        throw new TypeError("namespace must contain canonical segments");
-    }
-    const documents = await readRecentTaskDocuments(world, {
-        ...(namespace === undefined ? {} : { namespace }),
-        selection: "active",
-        ...(input.limit === undefined ? {} : { limit: input.limit }),
-    });
-    const known = new Map(documents.rows.map((document) => [document.id, document]));
-    return {
-        rows: await Promise.all(documents.rows.map((document) => catalogRow(world, document, known))),
-        hasMore: documents.hasMore,
-    };
-}

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

@@ -1,57 +0,0 @@
-import { type TaskBoard } from "./board.js";
-import type { TaskCompositionResult } from "./mutation-result.js";
-import { type TaskDocument } from "./document.js";
-import { type TaskId } from "./identity.js";
-import { type TaskCompositionDiagnostic } from "./operations.js";
-export declare function taskCompositionNamespaceHeader(markdown: string): Readonly<{
-    specified: boolean;
-    namespace?: readonly string[];
-}>;
-type PlannedComposition = Extract<TaskCompositionResult, {
-    kind: "planned";
-}>;
-export type AcceptedComposition = Extract<TaskCompositionResult, {
-    kind: "accepted";
-}>;
-export type TaskCompositionAlias = Readonly<AcceptedComposition["aliases"][number]>;
-export type TaskCompositionPlanAlias = Readonly<PlannedComposition["aliases"][number]>;
-export type TaskCompositionPlanOrder = Readonly<PlannedComposition["admissionOrder"][number]>;
-export type TaskCompositionBodyPreview = Readonly<PlannedComposition["bodies"][number]>;
-export type TaskCompositionAdmission = Readonly<PlannedComposition["admissions"][number]>;
-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[];
-    admissions: readonly Readonly<{
-        position: number;
-        kind: "new" | "existing";
-        taskId: TaskId;
-        alias?: string | undefined;
-        title: string;
-    }>[];
-    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;
-export {};