light-plan 0.0.0-stage → 0.1.0

package/dist/core/board/registry.d.ts

@@ -0,0 +1,51 @@
+import type { Template } from '../model/types.js';
+import type { LoadedBoard } from './load.js';
+/**
+ * Reading the template registry.
+ *
+ * The registry is a collection like any other, so loading, checking, moving and
+ * deleting come for free. What it adds is one distinction the other collections
+ * do not have: some of its documents are *containers* and the rest are the
+ * things somebody instantiates. Everything that depends on that distinction is
+ * here, so no front end has to re-derive it.
+ */
+/**
+ * A template somebody can instantiate: one whose parent is a folder, or nothing.
+ *
+ * Anything else is *inside* a template — the three stories under a feature
+ * template are part of the feature, not three separate offers — and a folder is
+ * scaffolding. So this is exactly the list the registry shows and exactly the
+ * set of ids `instantiate` accepts.
+ */
+export declare function isTemplateRoot(board: LoadedBoard, template: Template): boolean;
+/** Every template that can be instantiated, in registry order. */
+export declare function templateRoots(board: LoadedBoard): Template[];
+/** Resolve a template by id, case-insensitively, so `tpl-3` finds `TPL-3`. */
+export declare function findTemplate(board: LoadedBoard, id: string): Template | null;
+/** A template and everything nested under it, parents first. */
+export declare function templateSubtree(board: LoadedBoard, root: Template): Template[];
+/**
+ * The folder path a template sits under, outermost first — "Delivery / Backend".
+ * What makes a listing of forty templates readable.
+ */
+export declare function templatePath(board: LoadedBoard, template: Template): string[];
+/**
+ * Why this template may not sit under that parent, or null when it may.
+ *
+ * The depth rules are the hierarchy's and are checked everywhere else; this is
+ * the one rule the registry adds. A folder stands in for a level nobody
+ * templatized, so it belongs beside templates and never inside one — a folder
+ * halfway down a feature template would be a level of the produced issue tree
+ * with nothing to put in it.
+ */
+export declare function placementProblem(type: string, parent: {
+    type: string;
+    id: string;
+} | null): string | null;
+/** Throw when a placement breaks the rule above. */
+export declare function requirePlacement(type: string, parent: {
+    type: string;
+    id: string;
+} | null): void;
+/** Resolve a template that must exist, with a message naming the registry. */
+export declare function requireTemplate(board: LoadedBoard, id: string): Template;

package/dist/core/board/registry.js

@@ -0,0 +1,98 @@
+import { BoardError } from '../errors.js';
+import { TEMPLATE_FOLDER_TYPE, isFolderTemplate } from '../model/types.js';
+import { subtreeOf } from './query.js';
+/**
+ * Reading the template registry.
+ *
+ * The registry is a collection like any other, so loading, checking, moving and
+ * deleting come for free. What it adds is one distinction the other collections
+ * do not have: some of its documents are *containers* and the rest are the
+ * things somebody instantiates. Everything that depends on that distinction is
+ * here, so no front end has to re-derive it.
+ */
+/**
+ * A template somebody can instantiate: one whose parent is a folder, or nothing.
+ *
+ * Anything else is *inside* a template — the three stories under a feature
+ * template are part of the feature, not three separate offers — and a folder is
+ * scaffolding. So this is exactly the list the registry shows and exactly the
+ * set of ids `instantiate` accepts.
+ */
+export function isTemplateRoot(board, template) {
+    if (isFolderTemplate(template))
+        return false;
+    if (!template.parentId)
+        return true;
+    const parent = board.templatesById.get(template.parentId);
+    return parent ? isFolderTemplate(parent) : true;
+}
+/** Every template that can be instantiated, in registry order. */
+export function templateRoots(board) {
+    return board.templates.filter((template) => isTemplateRoot(board, template));
+}
+/** Resolve a template by id, case-insensitively, so `tpl-3` finds `TPL-3`. */
+export function findTemplate(board, id) {
+    const exact = board.templatesById.get(id);
+    if (exact)
+        return exact;
+    const wanted = id.toLowerCase();
+    return board.templates.find((template) => template.id.toLowerCase() === wanted) ?? null;
+}
+/** A template and everything nested under it, parents first. */
+export function templateSubtree(board, root) {
+    return subtreeOf(board.templates, root);
+}
+/**
+ * The folder path a template sits under, outermost first — "Delivery / Backend".
+ * What makes a listing of forty templates readable.
+ */
+export function templatePath(board, template) {
+    const names = [];
+    const seen = new Set([template.id]);
+    let current = template.parentId ? board.templatesById.get(template.parentId) : undefined;
+    while (current && !seen.has(current.id)) {
+        seen.add(current.id);
+        names.unshift(current.title);
+        current = current.parentId ? board.templatesById.get(current.parentId) : undefined;
+    }
+    return names;
+}
+/**
+ * Why this template may not sit under that parent, or null when it may.
+ *
+ * The depth rules are the hierarchy's and are checked everywhere else; this is
+ * the one rule the registry adds. A folder stands in for a level nobody
+ * templatized, so it belongs beside templates and never inside one — a folder
+ * halfway down a feature template would be a level of the produced issue tree
+ * with nothing to put in it.
+ */
+export function placementProblem(type, parent) {
+    if (type !== TEMPLATE_FOLDER_TYPE)
+        return null;
+    if (parent && parent.type !== TEMPLATE_FOLDER_TYPE) {
+        return `A folder cannot sit inside the template ${parent.id}`;
+    }
+    return null;
+}
+/** Throw when a placement breaks the rule above. */
+export function requirePlacement(type, parent) {
+    const problem = placementProblem(type, parent);
+    if (problem) {
+        throw new BoardError(problem, [
+            'Folders group templates; only templates and other folders go inside one.',
+        ]);
+    }
+}
+/** Resolve a template that must exist, with a message naming the registry. */
+export function requireTemplate(board, id) {
+    const template = findTemplate(board, id);
+    if (!template) {
+        throw new BoardError(`No template with id "${id}"`, [
+            board.templates.length
+                ? 'Run `lpm template list` to see the registry.'
+                : 'The registry is empty; add one with `lpm template new <type> -t "..."`.',
+        ]);
+    }
+    return template;
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/board/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/core/board/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGvC;;;;;;;;GAQG;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,KAAkB,EAAE,QAAkB;IACnE,IAAI,gBAAgB,CAAC,QAAQ,CAAC;QAAE,OAAO,KAAK,CAAC;IAC7C,IAAI,CAAC,QAAQ,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IACpC,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC1D,OAAO,MAAM,CAAC,CAAC,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAClD,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,aAAa,CAAC,KAAkB;IAC9C,OAAO,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,YAAY,CAAC,KAAkB,EAAE,EAAU;IACzD,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC1C,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,MAAM,MAAM,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC;IAChC,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC;AAC1F,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,eAAe,CAAC,KAAkB,EAAE,IAAc;IAChE,OAAO,SAAS,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,KAAkB,EAAE,QAAkB;IACjE,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAC5C,IAAI,OAAO,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACzF,OAAO,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACrB,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAC7B,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACrF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,MAA2C;IAE3C,IAAI,IAAI,KAAK,oBAAoB;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,oBAAoB,EAAE,CAAC;QACnD,OAAO,2CAA2C,MAAM,CAAC,EAAE,EAAE,CAAC;IAChE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,MAA2C;IAE3C,MAAM,OAAO,GAAG,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC/C,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,IAAI,UAAU,CAAC,OAAO,EAAE;YAC5B,0EAA0E;SAC3E,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,eAAe,CAAC,KAAkB,EAAE,EAAU;IAC5D,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,UAAU,CAAC,wBAAwB,EAAE,GAAG,EAAE;YAClD,KAAK,CAAC,SAAS,CAAC,MAAM;gBACpB,CAAC,CAAC,8CAA8C;gBAChD,CAAC,CAAC,yEAAyE;SAC9E,CAAC,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/core/board/remote-scopes.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Which documents each declared remote claims — and where two remotes claim
+ * the same ones.
+ *
+ * A remote mirrors a subtree (`scope: LP-10`) or, with no `scope`, the whole
+ * board. **Two remotes may never claim the same document.** A document
+ * mirrored to two trackers at once is filed twice, closed twice, and edited
+ * from two directions into a conflict nobody asked for — and no `on_delete`
+ * policy or three-way merge can dig it back out, because the two remotes have
+ * no idea the other exists.
+ *
+ * Half of that rule is already enforced where it can be answered from the
+ * config alone (`checkRemotes` in `config/schema.ts`): two equal scopes are
+ * the same subtree, and an absent scope contains every other. The other half
+ * needs the board tree, because "is LP-42 inside LP-10?" is a question about
+ * parenting, not about config — and that is this file. `config/schema.ts`
+ * says so in as many words and this is the check it points at.
+ *
+ * Pure: no disk, no network. It takes the issues and the declared scopes and
+ * returns a value, so `lpm check` (reporting a board that drifted into this
+ * state through a reparent, a hand edit or a merge) and `lpm remote add`
+ * (refusing to write one in the first place) enforce one rule rather than two
+ * that can disagree.
+ */
+import type { Issue } from '../model/types.js';
+/** One remote's claim, as the config declares it. */
+export interface DeclaredScope {
+    /** The remote's name, for naming it in a message. */
+    name: string;
+    /** The scope id, or undefined for the whole board. */
+    scope: string | undefined;
+}
+/** Two remotes claiming the same documents, and why. */
+export interface ScopeOverlap {
+    /** The remote whose scope contains the other's. */
+    outer: string;
+    /** The remote nested inside it. */
+    inner: string;
+    /** The outer remote's scope id (`undefined` — the whole board — never reaches here). */
+    outerScope: string;
+    /** The inner remote's scope id. */
+    innerScope: string;
+}
+/** A `scope:` naming a document the board does not have. */
+export interface StaleScope {
+    name: string;
+    scope: string;
+}
+/**
+ * Every pair of declared remotes whose scopes claim the same documents through
+ * *nesting* — one scope sitting at or inside the other.
+ *
+ * Equal scopes and an absent scope are left to `config/schema.ts`, which
+ * refuses them before a board with them can load at all; reporting them again
+ * here would say the same thing twice in different words. A scope naming no
+ * document claims nothing and cannot overlap — `staleScopes` reports it
+ * instead.
+ *
+ * Pairs come back in declaration order, outer remote first.
+ */
+export declare function scopeOverlaps(issues: readonly Issue[], remotes: readonly DeclaredScope[]): ScopeOverlap[];
+/**
+ * Declared scopes naming a document the board does not have — a subtree that
+ * was deleted, renamed or never existed. Such a remote mirrors nothing, which
+ * is worth saying out loud before somebody wonders why a sync is empty.
+ */
+export declare function staleScopes(issues: readonly Issue[], remotes: readonly DeclaredScope[]): StaleScope[];
+/** The declared scopes of a board's remotes, in declaration order. */
+export declare function declaredScopes(remotes: Record<string, {
+    scope?: string;
+}>): DeclaredScope[];

package/dist/core/board/remote-scopes.js

@@ -0,0 +1,103 @@
+/**
+ * Which documents each declared remote claims — and where two remotes claim
+ * the same ones.
+ *
+ * A remote mirrors a subtree (`scope: LP-10`) or, with no `scope`, the whole
+ * board. **Two remotes may never claim the same document.** A document
+ * mirrored to two trackers at once is filed twice, closed twice, and edited
+ * from two directions into a conflict nobody asked for — and no `on_delete`
+ * policy or three-way merge can dig it back out, because the two remotes have
+ * no idea the other exists.
+ *
+ * Half of that rule is already enforced where it can be answered from the
+ * config alone (`checkRemotes` in `config/schema.ts`): two equal scopes are
+ * the same subtree, and an absent scope contains every other. The other half
+ * needs the board tree, because "is LP-42 inside LP-10?" is a question about
+ * parenting, not about config — and that is this file. `config/schema.ts`
+ * says so in as many words and this is the check it points at.
+ *
+ * Pure: no disk, no network. It takes the issues and the declared scopes and
+ * returns a value, so `lpm check` (reporting a board that drifted into this
+ * state through a reparent, a hand edit or a merge) and `lpm remote add`
+ * (refusing to write one in the first place) enforce one rule rather than two
+ * that can disagree.
+ */
+/** Issue id → its parent's id, for walking ancestry upward. */
+function parentIndex(issues) {
+    const parents = new Map();
+    for (const issue of issues)
+        parents.set(issue.id, issue.parentId ?? undefined);
+    return parents;
+}
+/**
+ * True when `ancestorId` is `id` itself or sits above it in the tree. The walk
+ * is bounded by the number of issues, so a parent cycle arriving by hand edit
+ * or merge terminates rather than hanging the check that would report it.
+ */
+function isAtOrUnder(parents, id, ancestorId) {
+    let current = id;
+    for (let steps = 0; current !== undefined && steps <= parents.size; steps += 1) {
+        if (current === ancestorId)
+            return true;
+        current = parents.get(current);
+    }
+    return false;
+}
+/**
+ * Every pair of declared remotes whose scopes claim the same documents through
+ * *nesting* — one scope sitting at or inside the other.
+ *
+ * Equal scopes and an absent scope are left to `config/schema.ts`, which
+ * refuses them before a board with them can load at all; reporting them again
+ * here would say the same thing twice in different words. A scope naming no
+ * document claims nothing and cannot overlap — `staleScopes` reports it
+ * instead.
+ *
+ * Pairs come back in declaration order, outer remote first.
+ */
+export function scopeOverlaps(issues, remotes) {
+    const known = new Set(issues.map((issue) => issue.id));
+    const scoped = remotes.filter((remote) => remote.scope !== undefined && known.has(remote.scope));
+    if (scoped.length < 2)
+        return [];
+    const parents = parentIndex(issues);
+    const overlaps = [];
+    for (let i = 0; i < scoped.length; i += 1) {
+        for (let j = i + 1; j < scoped.length; j += 1) {
+            const a = scoped[i];
+            const b = scoped[j];
+            if (a.scope === b.scope)
+                continue; // config/schema.ts already refuses this
+            const bInsideA = isAtOrUnder(parents, b.scope, a.scope);
+            const aInsideB = isAtOrUnder(parents, a.scope, b.scope);
+            if (!bInsideA && !aInsideB)
+                continue;
+            const outer = bInsideA ? a : b;
+            const inner = bInsideA ? b : a;
+            overlaps.push({
+                outer: outer.name,
+                inner: inner.name,
+                outerScope: outer.scope,
+                innerScope: inner.scope,
+            });
+        }
+    }
+    return overlaps;
+}
+/**
+ * Declared scopes naming a document the board does not have — a subtree that
+ * was deleted, renamed or never existed. Such a remote mirrors nothing, which
+ * is worth saying out loud before somebody wonders why a sync is empty.
+ */
+export function staleScopes(issues, remotes) {
+    const known = new Set(issues.map((issue) => issue.id));
+    return remotes
+        .filter((remote) => remote.scope !== undefined)
+        .filter((remote) => !known.has(remote.scope))
+        .map((remote) => ({ name: remote.name, scope: remote.scope }));
+}
+/** The declared scopes of a board's remotes, in declaration order. */
+export function declaredScopes(remotes) {
+    return Object.entries(remotes).map(([name, remote]) => ({ name, scope: remote.scope }));
+}
+//# sourceMappingURL=remote-scopes.js.map

package/dist/core/board/remote-scopes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-scopes.js","sourceRoot":"","sources":["../../../src/core/board/remote-scopes.ts"],"names":[],"mappings":"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"}

package/dist/core/board/rollup.d.ts

@@ -0,0 +1,32 @@
+import type { Issue } from '../model/types.js';
+import type { LoadedBoard } from './load.js';
+/**
+ * Reading a board for the status roll-up: which parents disagree with the work
+ * inside them.
+ *
+ * Read-only, like the rest of `board/`. `operations/rollup.ts` is what writes
+ * the answer, and `validation/checks/rollup.ts` is what reports it.
+ *
+ * @see src/shared/rollup.ts for the rule itself and why it is that way.
+ */
+/** An ancestor that has to move, resolved to the document a caller can write. */
+export interface IssueRollup {
+    issue: Issue;
+    from: string;
+    to: string;
+}
+/**
+ * The ancestors of `issue` that its new status carries with it, nearest first.
+ *
+ * `issue` is the document as it now stands and `status` the status it now
+ * holds — pass both, because the board handle still shows what was there before
+ * the operation wrote, including the parent it sat under.
+ */
+export declare function rollupsFor(board: LoadedBoard, issue: Issue, status: string): IssueRollup[];
+/**
+ * Every parent on the board whose status disagrees with what is inside it.
+ *
+ * Deepest first, so one pass carries a closed story up through its feature to
+ * the epic above it, and the list can be written in the order it is returned.
+ */
+export declare function boardRollups(board: LoadedBoard): IssueRollup[];

package/dist/core/board/rollup.js

@@ -0,0 +1,67 @@
+import { statusRulesFor } from '../config/lookup.js';
+import { rollupsAcross, rollupsUpward } from '../../shared/rollup.js';
+/**
+ * Adapt a `LoadedBoard` to the id-based lookup `src/shared/rollup.ts` reads.
+ *
+ * Both overlays carry facts that are true but not yet on the board handle: core
+ * operations write straight to disk, so the issue `moveNode` just closed is
+ * still open in memory, one it reparented in the same call still sits where it
+ * was, and one `createIssue` just wrote is not there at all. Anything not named
+ * in an overlay is read off the board.
+ */
+function rollupLookupFor(board, status, parent) {
+    // `has`, not `??`: a node moved to the top level has a parent of `null`, and
+    // that is an answer rather than a miss.
+    const parentOf = (id) => parent.has(id) ? parent.get(id) : (board.byId.get(id)?.parentId ?? null);
+    // The overlay's own ids as well, so an issue written a moment ago counts
+    // among its parent's contents even though the handle has never seen it.
+    const ids = [...board.issues.map((issue) => issue.id), ...parent.keys()];
+    const children = new Map();
+    for (const id of new Set(ids)) {
+        const above = parentOf(id);
+        if (!above)
+            continue;
+        const list = children.get(above);
+        if (list)
+            list.push(id);
+        else
+            children.set(above, [id]);
+    }
+    return {
+        parentOf,
+        childIdsOf: (id) => children.get(id) ?? [],
+        statusOf: (id) => status.get(id) ?? board.byId.get(id)?.status ?? '',
+    };
+}
+function resolve(board, rollups) {
+    const out = [];
+    for (const rollup of rollups) {
+        const issue = board.byId.get(rollup.id);
+        if (issue)
+            out.push({ issue, from: rollup.from, to: rollup.to });
+    }
+    return out;
+}
+/**
+ * The ancestors of `issue` that its new status carries with it, nearest first.
+ *
+ * `issue` is the document as it now stands and `status` the status it now
+ * holds — pass both, because the board handle still shows what was there before
+ * the operation wrote, including the parent it sat under.
+ */
+export function rollupsFor(board, issue, status) {
+    return resolve(board, rollupsUpward(issue.id, rollupLookupFor(board, new Map([[issue.id, status]]), new Map([[issue.id, issue.parentId]])), statusRulesFor(board.config)));
+}
+/**
+ * Every parent on the board whose status disagrees with what is inside it.
+ *
+ * Deepest first, so one pass carries a closed story up through its feature to
+ * the epic above it, and the list can be written in the order it is returned.
+ */
+export function boardRollups(board) {
+    const ids = [...board.issues]
+        .sort((a, b) => b.depth - a.depth)
+        .map((issue) => issue.id);
+    return resolve(board, rollupsAcross(ids, rollupLookupFor(board, new Map(), new Map()), statusRulesFor(board.config)));
+}
+//# sourceMappingURL=rollup.js.map

package/dist/core/board/rollup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.js","sourceRoot":"","sources":["../../../src/core/board/rollup.ts"],"names":[],"mappings":"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"}

package/dist/core/board/scope.d.ts

@@ -0,0 +1,81 @@
+import type { ProfileScope } from '../model/profile.js';
+import type { Issue } from '../model/types.js';
+import type { LoadedBoard } from './load.js';
+/**
+ * Narrowing the board to one person's part of it.
+ *
+ * A `ProfileScope` names documents; a `ResolvedScope` is what that means on
+ * *this* board — the actual issues, the periods with their children folded in,
+ * and the names that matched nothing. Resolving once and asking many times is
+ * what keeps the filter cheap enough to sit inside `nextTasks`.
+ *
+ * One rule governs where this may be used: **scope decides what the board
+ * offers you, never what is reachable.** It filters recommendations and
+ * listings; it never hides a document you asked for by id, and it never hides
+ * work you have already picked up. Anything else and a dependency would point
+ * at something that, as far as you could tell, did not exist.
+ *
+ * It is routing, not access control. The board is a folder of markdown that the
+ * person holding the profile can read; this decides what gets handed to them,
+ * not what they are permitted to see.
+ */
+export interface ResolvedScope {
+    /** Issues everything must sit at or below. `null` when unrestricted. */
+    under: Issue[] | null;
+    /** Issues nothing may sit at or below. Empty when nothing is excluded. */
+    exclude: Issue[];
+    /** Issue types allowed, or `null` when unrestricted. */
+    types: string[] | null;
+    /** Period ids allowed, child periods included, or `null` when unrestricted. */
+    periods: Set<string> | null;
+    /** Names in the profile this board has nothing for. Reported, never fatal. */
+    unknown: string[];
+    /** False when nothing is declared, so every issue is in scope. */
+    active: boolean;
+}
+/** A scope that excludes nothing — what every caller without a profile gets. */
+export declare function fullScope(): ResolvedScope;
+/**
+ * What a profile's scope means on this board.
+ *
+ * A name that resolves to nothing is dropped and reported rather than throwing:
+ * one profile may well be pointed at a board that has moved on, and a developer
+ * whose CLI refuses to run because an epic was renamed is worse served than one
+ * who is told about it. What it does *not* do is quietly widen the scope — a
+ * declared list that resolves to nothing matches nothing, so a stale `under`
+ * fails closed and says so.
+ */
+export declare function resolveScope(board: LoadedBoard, scope: ProfileScope): ResolvedScope;
+export declare function inScope(scope: ResolvedScope, issue: Issue): boolean;
+/** The issues a scope leaves, in board order. */
+export declare function scopedIssues(board: LoadedBoard, scope: ResolvedScope): Issue[];
+/** One line saying what is being applied, for the CLI and for an agent to read. */
+export declare function describeScope(scope: ResolvedScope): string;
+/**
+ * A squad's member resource ids, resolved against the current roster.
+ *
+ * A member id the board no longer has is dropped and reported rather than
+ * throwing — a squad that named someone who has since left the roster is a fact
+ * the board should know, not a reason to stop loading. An empty squad matches
+ * nothing, never everything: the "stale scope fails closed" rule.
+ */
+export interface ResolvedSquad {
+    /** Resource ids that are on the roster. */
+    members: string[];
+    /** Member ids the board has nothing for. Reported, never fatal. */
+    unknown: string[];
+    /** False when the squad has no members, so nothing is matched. */
+    active: boolean;
+}
+/** A squad that has nothing to match — what every call falling through gets. */
+export declare function emptySquad(): ResolvedSquad;
+/**
+ * Resolve a squad to its current member resource ids.
+ *
+ * Follows the same "resolve once, ask many times" pattern as `resolveScope`:
+ * the result can be cached and reused for every issue in a period. A stale
+ * member id is dropped and reported in `unknown` — the "stale scope fails
+ * closed" rule — so a squad whose every member has left the roster matches
+ * nothing rather than everything.
+ */
+export declare function resolveSquad(board: LoadedBoard, squadId: string): ResolvedSquad;

package/dist/core/board/scope.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { isEmptyScope } from '../model/profile.js';
+import { findIssue, findPeriod, subtreeOf } from './query.js';
+/** A scope that excludes nothing — what every caller without a profile gets. */
+export function fullScope() {
+    return { under: null, exclude: [], types: null, periods: null, unknown: [], active: false };
+}
+function isAtOrBelow(issue, root) {
+    return issue.dir === root.dir || issue.dir.startsWith(root.dir + path.sep);
+}
+function resolveIssues(board, ids, unknown) {
+    const issues = [];
+    for (const id of ids) {
+        const issue = findIssue(board, id);
+        if (issue)
+            issues.push(issue);
+        else
+            unknown.push(id);
+    }
+    return issues;
+}
+/**
+ * A period holds work scheduled in it *and* in the periods below it, the same
+ * way `issuesInPeriod` does — naming an increment must not mean "the sprints
+ * inside it do not count".
+ */
+function resolvePeriods(board, ids, unknown) {
+    const allowed = new Set();
+    for (const id of ids) {
+        const period = findPeriod(board, id);
+        if (!period) {
+            unknown.push(id);
+            continue;
+        }
+        for (const node of subtreeOf(board.periods, period))
+            allowed.add(node.id);
+    }
+    return allowed;
+}
+function resolveTypes(board, names, unknown) {
+    const types = [];
+    for (const name of names) {
+        if (board.config.issue_types[name])
+            types.push(name);
+        else
+            unknown.push(name);
+    }
+    return types;
+}
+/**
+ * What a profile's scope means on this board.
+ *
+ * A name that resolves to nothing is dropped and reported rather than throwing:
+ * one profile may well be pointed at a board that has moved on, and a developer
+ * whose CLI refuses to run because an epic was renamed is worse served than one
+ * who is told about it. What it does *not* do is quietly widen the scope — a
+ * declared list that resolves to nothing matches nothing, so a stale `under`
+ * fails closed and says so.
+ */
+export function resolveScope(board, scope) {
+    if (isEmptyScope(scope))
+        return fullScope();
+    const unknown = [];
+    return {
+        under: scope.under ? resolveIssues(board, scope.under, unknown) : null,
+        exclude: scope.exclude ? resolveIssues(board, scope.exclude, unknown) : [],
+        types: scope.types ? resolveTypes(board, scope.types, unknown) : null,
+        periods: scope.periods ? resolvePeriods(board, scope.periods, unknown) : null,
+        unknown,
+        active: true,
+    };
+}
+export function inScope(scope, issue) {
+    if (!scope.active)
+        return true;
+    if (scope.exclude.some((root) => isAtOrBelow(issue, root)))
+        return false;
+    if (scope.under && !scope.under.some((root) => isAtOrBelow(issue, root)))
+        return false;
+    if (scope.types && !scope.types.includes(issue.type))
+        return false;
+    if (scope.periods && !(issue.period && scope.periods.has(issue.period)))
+        return false;
+    return true;
+}
+/** The issues a scope leaves, in board order. */
+export function scopedIssues(board, scope) {
+    return scope.active ? board.issues.filter((issue) => inScope(scope, issue)) : board.issues;
+}
+/** One line saying what is being applied, for the CLI and for an agent to read. */
+export function describeScope(scope) {
+    if (!scope.active)
+        return 'the whole board';
+    const parts = [];
+    if (scope.under)
+        parts.push(`under ${scope.under.map((issue) => issue.id).join(', ') || 'nothing'}`);
+    if (scope.exclude.length)
+        parts.push(`not ${scope.exclude.map((issue) => issue.id).join(', ')}`);
+    if (scope.types)
+        parts.push(scope.types.join('/') || 'no type');
+    if (scope.periods)
+        parts.push(`in ${[...scope.periods].join(', ') || 'no period'}`);
+    return parts.join(' · ');
+}
+/** A squad that has nothing to match — what every call falling through gets. */
+export function emptySquad() {
+    return { members: [], unknown: [], active: false };
+}
+/**
+ * Resolve a squad to its current member resource ids.
+ *
+ * Follows the same "resolve once, ask many times" pattern as `resolveScope`:
+ * the result can be cached and reused for every issue in a period. A stale
+ * member id is dropped and reported in `unknown` — the "stale scope fails
+ * closed" rule — so a squad whose every member has left the roster matches
+ * nothing rather than everything.
+ */
+export function resolveSquad(board, squadId) {
+    const squad = board.squadsById.get(squadId);
+    if (!squad)
+        return emptySquad();
+    const members = [];
+    const unknown = [];
+    for (const id of squad.members) {
+        if (board.resourcesById.has(id)) {
+            members.push(id);
+        }
+        else {
+            unknown.push(id);
+        }
+    }
+    return { members, unknown, active: members.length > 0 };
+}
+//# sourceMappingURL=scope.js.map