@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/kanshi/read.js

@@ -1,8 +1,16 @@
-import { resolve } from "node:path";
-import { listKeiyaku, taskHoldersForRepo } from "../library/contract.js";
-import { NoGitWorldError, Repo } from "../library/repo.js";
-import { Tasks } from "../task/index.js";
+import { Repo } from "../library/repo.js";
+import { scopeForRepo } from "../library/repo.js";
+import { observeTaskStatusRows } from "../task/operations.js";
 import { Akuma } from "../akuma/index.js";
+import { readAliases } from "../alias/index.js";
+import { readDispatchesAt } from "../dispatch/index.js";
+import { readTaskHolderProjectionAt } from "../settlement/holder.js";
+import { readContractBoard } from "../protocol/read/status.js";
+import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
+import { readDocuments } from "../protocol/read/documents.js";
+import { readRegionDeclarations, validateRegionPath } from "../library/region.js";
+import { contractId } from "../core/facts/types.js";
+import { selectRegion } from "./select.js";
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -20,81 +28,273 @@ function diagnostic(error) {
     const line = source.replaceAll(/\s+/gu, " ").trim();
     return line.length <= 240 ? line : `${line.slice(0, 239)}…`;
 }
+function record(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new TypeError(`kanshi ${label} must be an object`);
+    return value;
+}
+function exactKeys(value, allowed, label) {
+    for (const key of Object.keys(value))
+        if (!allowed.includes(key))
+            throw new TypeError(`kanshi ${label} has unknown field: ${key}`);
+}
+function regionSelection(value) {
+    const selection = record(value, "region selection");
+    if (typeof selection.kind !== "string")
+        throw new TypeError("kanshi region selection kind must be a string");
+    if (selection.kind === "declarations") {
+        exactKeys(selection, ["kind"], "region selection");
+        return { kind: "declarations" };
+    }
+    if (selection.kind === "contract") {
+        exactKeys(selection, ["kind", "contract"], "region selection");
+        if (typeof selection.contract !== "string")
+            throw new TypeError("kanshi region contract must be a ContractId");
+        try {
+            return { kind: "contract", contract: contractId(selection.contract) };
+        }
+        catch {
+            throw new TypeError("kanshi region contract must be a canonical ContractId");
+        }
+    }
+    if (selection.kind === "overlap") {
+        exactKeys(selection, ["kind", "contract"], "region selection");
+        if (selection.contract === undefined)
+            return { kind: "overlap" };
+        if (typeof selection.contract !== "string")
+            throw new TypeError("kanshi region contract must be a ContractId");
+        try {
+            return { kind: "overlap", contract: contractId(selection.contract) };
+        }
+        catch {
+            throw new TypeError("kanshi region contract must be a canonical ContractId");
+        }
+    }
+    if (selection.kind === "path") {
+        exactKeys(selection, ["kind", "path"], "region selection");
+        try {
+            validateRegionPath(selection.path);
+        }
+        catch (error) {
+            throw new TypeError(error instanceof Error ? error.message : String(error));
+        }
+        return { kind: "path", path: selection.path };
+    }
+    throw new TypeError(`kanshi region selection kind is invalid: ${selection.kind}`);
+}
 function coordinate(input) {
-    if (input === undefined)
-        return process.cwd();
     if (typeof input !== "object" || input === null || Array.isArray(input))
         throw new TypeError("kanshi input must be an object");
     for (const key of Object.keys(input))
-        if (key !== "path")
+        if (key !== "world" && key !== "repo" && key !== "region")
             throw new TypeError(`kanshi input has unknown field: ${key}`);
-    if (input.path === undefined)
-        return process.cwd();
-    if (typeof input.path !== "string" || input.path.trim().length === 0)
-        throw new TypeError("kanshi path must be a nonblank string");
-    return input.path;
+    if (input.world !== null && (typeof input.world !== "string" || input.world.trim().length === 0)) {
+        throw new TypeError("kanshi world must be a WorldRoot or null");
+    }
+    if (input.repo !== undefined && !(input.repo instanceof Repo))
+        throw new TypeError("kanshi repo must be a Repo");
+    return input.region === undefined ? input : { ...input, region: regionSelection(input.region) };
 }
-async function readContracts(path) {
+async function readRegion(observation, selection) {
     try {
-        const repo = Repo.at({ path });
-        try {
-            return { repo, section: { kind: "present", value: await listKeiyaku({ repo }) } };
-        }
-        catch (error) {
-            return { repo, section: { kind: "failed", failure: { message: diagnostic(error) } } };
-        }
+        const declarations = [...readRegionDeclarations(await readDocuments(observation))].sort((left, right) => left.contract.localeCompare(right.contract));
+        return { kind: "present", value: selectRegion({ declarations, selection }) };
     }
     catch (error) {
-        return { section: error instanceof NoGitWorldError
-                ? { kind: "absent" }
-                : { kind: "failed", failure: { message: diagnostic(error) } } };
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+async function readBranch(repo) {
+    if (repo === undefined)
+        return null;
+    try {
+        return await repo.currentBranch();
+    }
+    catch {
+        return null;
+    }
+}
+async function readContracts(observation) {
+    try {
+        return { kind: "present", value: await readContractBoard(observation) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+async function readHolders(observation) {
+    try {
+        return { kind: "present", value: await readTaskHolderProjectionAt(observation) };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+function attachFleet(contracts, akuma) {
+    if (contracts.kind !== "present")
+        return contracts;
+    const attachments = new Map();
+    if (akuma.kind === "present") {
+        for (const row of akuma.value.rows) {
+            if (row.contract === undefined)
+                continue;
+            const current = attachments.get(row.contract.id) ?? [];
+            current.push({ id: row.id, aliases: row.aliases });
+            attachments.set(row.contract.id, current);
+        }
     }
+    return {
+        kind: "present",
+        value: {
+            ...contracts.value,
+            rows: contracts.value.rows.map((row) => ({ ...row, fleet: attachments.get(row.id) ?? [] })),
+        },
+    };
+}
+function decorateContracts(contracts, holders) {
+    if (contracts.kind !== "present")
+        return contracts;
+    return {
+        kind: "present",
+        value: {
+            ...contracts.value,
+            rows: contracts.value.rows.map((row) => {
+                if (holders.kind === "failed")
+                    return { ...row, holder: { kind: "unavailable" }, fleet: [] };
+                const holder = holders.kind === "present" ? holders.value.get(row.id) : undefined;
+                return {
+                    ...row,
+                    fleet: [],
+                    holder: holder?.disposition === "held"
+                        ? { kind: "held", taskId: holder.taskId }
+                        : { kind: "none" },
+                };
+            }),
+        },
+    };
 }
-function joinTasks(rows, holders, contracts) {
+function contractEndpointObserver(contracts) {
     const dispositions = contracts.kind === "present"
         ? new Map(contracts.value.rows.map((row) => [row.id, row.disposition]))
         : null;
-    const associations = new Map(holders
-        .filter((holder) => holder.disposition === "held")
-        .map((holder) => [holder.taskId, holder.contractId]));
+    return (id) => dispositions === null ? "unavailable" : dispositions.get(id) ?? "missing";
+}
+function joinTasks(rows, holders, observeContract) {
+    const associations = new Map(holders.kind === "present"
+        ? [...holders.value.values()]
+            .filter((holder) => holder.disposition === "held")
+            .map((holder) => [holder.taskId, holder.contractId])
+        : []);
     return rows.map((row) => {
         const contractId = associations.get(row.id);
         if (contractId === undefined)
             return row;
-        const observed = contracts.kind !== "present"
-            ? "unavailable"
-            : dispositions?.get(contractId) ?? "missing";
-        return { ...row, contract: { id: contractId, observed } };
+        return { ...row, contract: { id: contractId, observed: observeContract(contractId) } };
     });
 }
-async function readTasks(path, contracts, repo) {
+async function readTasks(path, holders, observeContract) {
+    if (holders.kind === "failed")
+        return { kind: "failed", failure: holders.failure };
+    try {
+        return {
+            kind: "present",
+            value: { root: path, rows: joinTasks(await observeTaskStatusRows(path), holders, observeContract) },
+        };
+    }
+    catch (error) {
+        return { kind: "failed", failure: { message: diagnostic(error) } };
+    }
+}
+async function joinAkuma(path, observeContract, dispatches) {
     try {
-        const tasks = Tasks.at({ path });
-        const result = await tasks.list({ selection: "all", scope: "world" });
-        if (result.kind !== "accepted")
-            return { kind: "failed", failure: { message: diagnostic(result) } };
+        const source = await Akuma.of(path).list();
+        const aliases = await readAliases(path);
+        const aliasById = new Map();
+        for (const binding of aliases)
+            aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
+        const dispatchById = new Map(dispatches.map((dispatch) => [dispatch.akuId, dispatch]));
         return {
             kind: "present",
-            value: { root: tasks.root, rows: joinTasks(result.value, repo === undefined ? [] : taskHoldersForRepo(repo), contracts) },
+            value: {
+                ...source,
+                rows: source.rows.map((row) => {
+                    const dispatch = dispatchById.get(row.id);
+                    return {
+                        ...row,
+                        aliases: (aliasById.get(row.id) ?? []).map((binding) => binding.alias),
+                        ...(dispatch === undefined ? {} : {
+                            contract: {
+                                id: dispatch.contractId,
+                                observed: observeContract(dispatch.contractId),
+                            },
+                        }),
+                    };
+                }),
+            },
         };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-function readAkuma(path) {
+async function readDispatches(observation) {
     try {
-        const source = Akuma.at({ path }).list();
-        return { kind: "present", value: source };
+        return { kind: "present", value: await readDispatchesAt(observation) };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
 export async function kanshi(input) {
-    const path = resolve(coordinate(input));
-    const contractRead = await readContracts(path);
-    const contracts = contractRead.section;
-    const tasks = await readTasks(path, contracts, contractRead.repo);
-    return { root: path, contracts, tasks, akuma: readAkuma(path) };
+    const observedAt = new Date().toISOString();
+    const { world, repo } = coordinate(input);
+    const branch = await readBranch(repo);
+    if (repo === undefined) {
+        const contracts = { kind: "absent" };
+        const holders = { kind: "absent" };
+        const observeContract = contractEndpointObserver(contracts);
+        const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
+        const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, []);
+        return { root: world, observedAt, branch, contracts, tasks, akuma, ...(input.region === undefined ? {} : { region: { kind: "absent" } }) };
+    }
+    try {
+        const repository = scopeForRepo(repo);
+        return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, async (observation) => {
+            const [contractSection, holders, dispatches, region] = await Promise.all([
+                readContracts(observation),
+                readHolders(observation),
+                readDispatches(observation),
+                input.region === undefined ? Promise.resolve(undefined) : readRegion(observation, input.region),
+            ]);
+            const contracts = decorateContracts(contractSection, holders);
+            const observeContract = contractEndpointObserver(contracts);
+            const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
+            const akuma = world === null
+                ? { kind: "absent" }
+                : dispatches.kind === "failed"
+                    ? dispatches
+                    : await joinAkuma(world, observeContract, dispatches.value);
+            return {
+                root: world,
+                observedAt,
+                branch,
+                contracts: attachFleet(contracts, akuma),
+                tasks,
+                akuma,
+                ...(region === undefined ? {} : { region }),
+            };
+        }));
+    }
+    catch (error) {
+        const failure = { kind: "failed", failure: { message: diagnostic(error) } };
+        return {
+            root: world,
+            observedAt,
+            branch,
+            contracts: failure,
+            tasks: world === null ? { kind: "absent" } : failure,
+            akuma: world === null ? { kind: "absent" } : failure,
+            ...(input.region === undefined ? {} : { region: failure }),
+        };
+    }
 }

package/build/src/kanshi/report.d.ts

@@ -1,6 +1,9 @@
-import type { ContractBoard, ContractDisposition } from "../index.js";
-import type { TaskRow } from "../task/index.js";
+import type { ContractBoard, ContractDisposition } from "../library/contract.js";
+import type { TaskId, TaskRef, TaskRow } from "../task/index.js";
 import type { AkumaList, AkumaListRow, UnbornAkumaListRow } from "../akuma/index.js";
+import type { AkumaAlias } from "../identity/selector.js";
+import type { WorldRoot } from "../world.js";
+import type { ContractId } from "../library/contract.js";
 export type Section<Value> = Readonly<{
     kind: "present";
     value: Value;
@@ -13,23 +16,95 @@ export type Section<Value> = Readonly<{
     }>;
 }>;
 export type ContractEndpointObservation = ContractDisposition | "missing" | "unavailable";
+export type ContractHolderObservation = Readonly<{
+    kind: "held";
+    taskId: TaskId;
+}> | Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "unavailable";
+}>;
+export type ContractFleetAttachment = Readonly<{
+    id: string;
+    aliases: readonly AkumaAlias[];
+}>;
+export type ContractKanshiRow = ContractBoard["rows"][number] & Readonly<{
+    holder: ContractHolderObservation;
+    fleet: readonly ContractFleetAttachment[];
+}>;
+export type ContractKanshiBoard = Omit<ContractBoard, "rows"> & Readonly<{
+    rows: readonly ContractKanshiRow[];
+}>;
 export type TaskKanshiRow = TaskRow & Readonly<{
     contract?: Readonly<{
         id: string;
         observed: ContractEndpointObservation;
     }>;
+    blockers?: readonly TaskRef[];
 }>;
 export type TaskKanshiWorld = Readonly<{
-    root: string;
+    root: WorldRoot;
     rows: readonly TaskKanshiRow[];
 }>;
-export type AkumaKanshiRow = AkumaListRow | UnbornAkumaListRow;
+export type AkumaKanshiRow = (AkumaListRow | UnbornAkumaListRow) & Readonly<{
+    aliases: readonly AkumaAlias[];
+    contract?: Readonly<{
+        id: string;
+        observed: ContractEndpointObservation;
+    }>;
+}>;
 export type AkumaKanshiWorld = Omit<AkumaList, "rows"> & Readonly<{
     rows: readonly AkumaKanshiRow[];
 }>;
+export type KanshiRegionSelection = Readonly<{
+    kind: "declarations";
+}> | Readonly<{
+    kind: "contract";
+    contract: ContractId;
+}> | Readonly<{
+    kind: "overlap";
+    contract?: ContractId;
+}> | Readonly<{
+    kind: "path";
+    path: string;
+}>;
+export type RegionDeclaration = Readonly<{
+    contract: ContractId;
+    patterns: readonly string[];
+}>;
+export type RegionIntersection = Readonly<{
+    left: ContractId;
+    right: ContractId;
+    patterns: readonly Readonly<{
+        left: string;
+        right: string;
+    }>[];
+}>;
+export type RegionPathMatch = Readonly<{
+    contract: ContractId;
+    pattern: string;
+}>;
+export type RegionRead = Readonly<{
+    kind: "declarations";
+    declarations: readonly RegionDeclaration[];
+}> | Readonly<{
+    kind: "contract";
+    declaration: RegionDeclaration;
+}> | Readonly<{
+    kind: "overlap";
+    subject?: ContractId;
+    intersections: readonly RegionIntersection[];
+}> | Readonly<{
+    kind: "path";
+    path: string;
+    matches: readonly RegionPathMatch[];
+}>;
 export type KanshiReport = Readonly<{
-    root: string;
-    contracts: Section<ContractBoard>;
+    root: WorldRoot | null;
+    observedAt: string;
+    branch: string | null;
+    contracts: Section<ContractKanshiBoard>;
     tasks: Section<TaskKanshiWorld>;
     akuma: Section<AkumaKanshiWorld>;
+    region?: Section<RegionRead>;
 }>;

package/build/src/kanshi/select.d.ts

@@ -1,4 +1,5 @@
 import type { KanshiReport } from "./report.js";
+import type { KanshiRegionSelection, RegionDeclaration, RegionRead } from "./report.js";
 export type KanshiSelection = Readonly<{
     contract: string;
 }>;
@@ -6,3 +7,7 @@ export declare function selectKanshi(input: Readonly<{
     report: KanshiReport;
     contract: string;
 }>): KanshiReport;
+export declare function selectRegion(input: Readonly<{
+    declarations: readonly RegionDeclaration[];
+    selection: KanshiRegionSelection;
+}>): RegionRead;

package/build/src/kanshi/select.js

@@ -1,3 +1,4 @@
+import { regionIntersections, regionPathMatches } from "../library/region.js";
 export function selectKanshi(input) {
     const { report, contract } = input;
     return {
@@ -13,9 +14,40 @@ export function selectKanshi(input) {
                 kind: "present",
                 value: {
                     ...report.akuma.value,
-                    rows: [],
+                    rows: report.akuma.value.rows.filter((row) => row.contract?.id === contract),
                 },
             }
             : report.akuma,
     };
 }
+export function selectRegion(input) {
+    const { declarations, selection } = input;
+    if (selection.kind === "declarations")
+        return { kind: "declarations", declarations };
+    if (selection.kind === "contract") {
+        const declaration = declarations.find((value) => value.contract === selection.contract);
+        if (declaration === undefined)
+            throw new Error(`active contract not found: ${selection.contract}`);
+        return { kind: "contract", declaration };
+    }
+    if (selection.kind === "path") {
+        const matches = declarations.flatMap((declaration) => regionPathMatches(declaration.patterns, selection.path).map((pattern) => ({ contract: declaration.contract, pattern })));
+        return { kind: "path", path: selection.path, matches };
+    }
+    const intersections = [];
+    for (let leftIndex = 0; leftIndex < declarations.length; leftIndex += 1) {
+        for (let rightIndex = leftIndex + 1; rightIndex < declarations.length; rightIndex += 1) {
+            const left = declarations[leftIndex];
+            const right = declarations[rightIndex];
+            if (selection.contract !== undefined && left.contract !== selection.contract && right.contract !== selection.contract)
+                continue;
+            const patterns = regionIntersections(left.patterns, right.patterns);
+            if (patterns.length > 0)
+                intersections.push({ left: left.contract, right: right.contract, patterns });
+        }
+    }
+    if (selection.contract !== undefined && !declarations.some((value) => value.contract === selection.contract)) {
+        throw new Error(`active contract not found: ${selection.contract}`);
+    }
+    return { kind: "overlap", ...(selection.contract === undefined ? {} : { subject: selection.contract }), intersections };
+}

package/build/src/library/address.d.ts

@@ -0,0 +1,57 @@
+import { type AkuId } from "../akuma/identity.js";
+import { type AkumaAlias, type AkumaGlob } from "../identity/selector.js";
+import type { Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
+import { type Repo } from "./repo.js";
+export type DirectAkumaSelector = AkuId | AkumaAlias;
+export type SetAkumaSelector = DirectAkumaSelector | AkumaGlob | `kei/${string}`;
+export type AkumaAddressInput = Readonly<{
+    path: WorldRoot;
+    akuma: string;
+    settings?: Settings;
+    repo?: Repo;
+}>;
+export type AkumaSetAddressInput = Readonly<{
+    path: WorldRoot;
+    akuma: readonly string[];
+    settings?: Settings;
+    repo?: Repo;
+}>;
+export type AkumaWorldScopeRefusal = Readonly<{
+    kind: "akuma-not-in-world";
+    ids: readonly AkuId[];
+    world: WorldRoot;
+}>;
+export declare class AkumaWorldScopeError extends TypeError {
+    readonly refusal: AkumaWorldScopeRefusal;
+    constructor(refusal: AkumaWorldScopeRefusal);
+}
+export type NamedAddressContract = Readonly<{
+    id: string;
+    disposition: "active" | "terminal";
+    workspace: "worktree" | "here";
+    worktreePath: string | null;
+}>;
+export type NamedAddress = Readonly<{
+    kind: "contract";
+    id: string;
+}> | Readonly<{
+    kind: "akuma";
+    id: AkuId;
+}>;
+export type NamedAddressInput = Readonly<{
+    path: WorldRoot | null;
+    selector: string;
+    contracts: readonly NamedAddressContract[];
+}>;
+export declare function resolveNamedAddress(input: NamedAddressInput): Promise<NamedAddress>;
+export declare function addressAkuma(input: AkumaAddressInput): Promise<Readonly<{
+    path: WorldRoot;
+    id: AkuId;
+    settings?: Settings;
+}>>;
+export declare function addressAkumaSet(input: AkumaSetAddressInput): Promise<Readonly<{
+    path: WorldRoot;
+    ids: readonly AkuId[];
+    settings?: Settings;
+}>>;