@tomradex/domain 0.0.0-stage → 0.2.0

package/dist/query.d.ts

@@ -0,0 +1,65 @@
+import { type FieldDef } from "./fields.js";
+import type { FieldValue, Item } from "./types.js";
+/**
+ * How a view draws the backlog. Board and table group and sort; a graph draws
+ * the edges a plugin contributes. A view is one layout plus one query.
+ */
+export type Layout = "board" | "table" | "graph";
+export declare const LAYOUTS: readonly Layout[];
+/**
+ * `in` / `not-in` take values; a null value means "empty". `contains` is a
+ * case-insensitive substring over text. `gte` / `lte` compare numbers and dates.
+ */
+export type FilterOp = "in" | "not-in" | "contains" | "gte" | "lte";
+export interface FilterClause {
+    field: string;
+    op: FilterOp;
+    values: (FieldValue | null)[];
+}
+export interface SortKey {
+    field: string;
+    dir: "asc" | "desc";
+}
+/**
+ * The stored shape of a view's query and the live shape the bar edits. Empty
+ * `columns` means every key the field has; empty `sortBy` means manual order.
+ */
+export interface ViewQuery {
+    filter: FilterClause[];
+    /** Board layout: the field one column stands for. */
+    columnBy: string | null;
+    /** Visible column keys in order; empty shows them all. */
+    columns: string[];
+    /** Swimlanes on a board, groups in a table. */
+    groupBy: string | null;
+    sortBy: SortKey[];
+    /** Fields drawn on cards and as table columns; empty means the layout's default. */
+    fields: string[];
+    /** WIP cap per column key. Advisory — a drop is never blocked. */
+    wip: Record<string, number>;
+    /** Graph layout: the contributed graph whose edges are drawn. */
+    graph: string | null;
+}
+export declare const EMPTY_QUERY: ViewQuery;
+/** Fill a partially stored query so every consumer sees the full shape. */
+export declare const normalizeQuery: (q: Partial<ViewQuery> | null | undefined) => ViewQuery;
+export interface QueryContext {
+    defs: Map<string, FieldDef>;
+    /** Position of an option in its field's order; used to sort and to order columns. */
+    optionRank(fieldId: string, key: string): number;
+    /** A display name for an option key, for sorting fields whose options have no rank (epics by title). */
+    optionName(fieldId: string, key: string): string;
+}
+/** A `YYYY-MM-DD` bound against an epoch-ms value covers the whole day it names. */
+export declare function dayBound(value: FieldValue | null | undefined, op: "gte" | "lte"): number | null;
+export declare function matchesClause(item: Item, clause: FilterClause): boolean;
+export declare const matchesFilter: (item: Item, filter: FilterClause[]) => boolean;
+/** A comparable for one sort key: numbers for numeric fields, strings otherwise, null when empty. */
+export declare function sortKeyOf(item: Item, fieldId: string, ctx: QueryContext): number | string | null;
+/** Empty values sort last whichever direction; ties fall through to manual rank, then recency. */
+export declare function compareItems(a: Item, b: Item, sortBy: SortKey[], ctx: QueryContext, rankOf: (item: Item) => number): number;
+/** The keys a groupable field can take, in the field's order, with the empty key last where it applies. */
+export declare function groupSpaceOf(def: FieldDef, options: {
+    id: string;
+}[]): string[];
+//# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -0,0 +1,99 @@
+import { CHECKED, EMPTY_KEY, fieldValueOf } from "./fields.js";
+export const LAYOUTS = ["board", "table", "graph"];
+export const EMPTY_QUERY = { filter: [], columnBy: "status", columns: [], groupBy: null, sortBy: [], fields: [], wip: {}, graph: null };
+/** Fill a partially stored query so every consumer sees the full shape. */
+export const normalizeQuery = (q) => ({ ...EMPTY_QUERY, ...(q ?? {}), wip: { ...(q?.wip ?? {}) } });
+const norm = (v) => (v === null ? null : String(v));
+const DAY = 86_400_000;
+/** A `YYYY-MM-DD` bound against an epoch-ms value covers the whole day it names. */
+export function dayBound(value, op) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number")
+        return value;
+    const t = Date.parse(value);
+    if (Number.isNaN(t))
+        return null;
+    return op === "lte" ? t + DAY - 1 : t;
+}
+export function matchesClause(item, clause) {
+    const raw = fieldValueOf(item, clause.field);
+    const values = Array.isArray(raw) ? raw : raw === null ? [] : [raw];
+    switch (clause.op) {
+        case "in": {
+            const wanted = new Set(clause.values.map(norm));
+            if (!values.length)
+                return wanted.has(null);
+            return values.some((v) => wanted.has(String(v)));
+        }
+        case "not-in": {
+            const wanted = new Set(clause.values.map(norm));
+            if (!values.length)
+                return !wanted.has(null);
+            return !values.some((v) => wanted.has(String(v)));
+        }
+        case "contains": {
+            const needle = String(clause.values[0] ?? "").toLowerCase();
+            if (!needle)
+                return true;
+            return values.some((v) => String(v).toLowerCase().includes(needle));
+        }
+        case "gte":
+        case "lte": {
+            if (!values.length)
+                return false;
+            const v = values[0];
+            // A numeric field may be bounded by a date string (Updated); anything else compares like for like.
+            const bound = typeof v === "number" ? dayBound(clause.values[0], clause.op) : (clause.values[0] ?? null);
+            if (bound === null)
+                return false;
+            const cmp = typeof v === "number" && typeof bound === "number" ? v - bound : String(v).localeCompare(String(bound));
+            return clause.op === "gte" ? cmp >= 0 : cmp <= 0;
+        }
+    }
+}
+export const matchesFilter = (item, filter) => filter.every((c) => matchesClause(item, c));
+/** A comparable for one sort key: numbers for numeric fields, strings otherwise, null when empty. */
+export function sortKeyOf(item, fieldId, ctx) {
+    const raw = fieldValueOf(item, fieldId);
+    if (raw === null || Array.isArray(raw))
+        return null;
+    const def = ctx.defs.get(fieldId);
+    if (!def)
+        return null;
+    if (def.type === "select")
+        return ctx.optionRank(fieldId, String(raw));
+    if (def.type === "item")
+        return ctx.optionName(fieldId, String(raw)).toLowerCase();
+    if (def.type === "text")
+        return String(raw).toLowerCase();
+    return raw;
+}
+/** Empty values sort last whichever direction; ties fall through to manual rank, then recency. */
+export function compareItems(a, b, sortBy, ctx, rankOf) {
+    for (const key of sortBy) {
+        const ka = sortKeyOf(a, key.field, ctx);
+        const kb = sortKeyOf(b, key.field, ctx);
+        if (ka === kb)
+            continue;
+        if (ka === null)
+            return 1;
+        if (kb === null)
+            return -1;
+        const cmp = typeof ka === "number" && typeof kb === "number" ? ka - kb : String(ka).localeCompare(String(kb));
+        if (cmp !== 0)
+            return key.dir === "desc" ? -cmp : cmp;
+    }
+    return rankOf(a) - rankOf(b) || b.updatedAt - a.updatedAt;
+}
+/** The keys a groupable field can take, in the field's order, with the empty key last where it applies. */
+export function groupSpaceOf(def, options) {
+    if (def.type === "checkbox")
+        return [String(CHECKED), EMPTY_KEY];
+    const keys = options.map((o) => o.id);
+    // Total fields: every item has a status, a priority, a provenance and a workstream.
+    if (def.id === "status" || def.id === "priority" || def.id === "provenance" || def.id === "board")
+        return keys;
+    return [...keys, EMPTY_KEY];
+}
+//# sourceMappingURL=query.js.map

package/dist/schema.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+export declare const itemKindSchema: z.ZodEnum<{
+    ticket: "ticket";
+    epic: "epic";
+}>;
+export declare const workTypeSchema: z.ZodEnum<{
+    coding: "coding";
+    general: "general";
+}>;
+export declare const itemStatusSchema: z.ZodEnum<{
+    backlog: "backlog";
+    todo: "todo";
+    doing: "doing";
+    verifying: "verifying";
+    done: "done";
+    cancelled: "cancelled";
+}>;
+export declare const prioritySchema: z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+export declare const listItemsFilterSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    boardId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        ticket: "ticket";
+        epic: "epic";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    label: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    search: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const fieldValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+/** A key set to null clears the value. */
+export declare const fieldsPatchSchema: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+export declare const filterClauseSchema: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        in: "in";
+        "not-in": "not-in";
+        contains: "contains";
+        gte: "gte";
+        lte: "lte";
+    }>;
+    values: z.ZodArray<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+}, z.core.$strip>;
+export declare const sortKeySchema: z.ZodObject<{
+    field: z.ZodString;
+    dir: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>;
+}, z.core.$strip>;
+export declare const createItemSchema: z.ZodObject<{
+    playbookId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        ticket: "ticket";
+        epic: "epic";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    projectId: z.ZodOptional<z.ZodString>;
+    boardId: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+}, z.core.$strip>;
+export declare const patchSchema: z.ZodObject<{
+    playbookId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        ticket: "ticket";
+        epic: "epic";
+    }>>;
+    workType: z.ZodOptional<z.ZodEnum<{
+        coding: "coding";
+        general: "general";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        todo: "todo";
+        doing: "doing";
+        verifying: "verifying";
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    rank: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const itemKindSchema = z.enum(["ticket", "epic"]);
+export const workTypeSchema = z.enum(["coding", "general"]);
+export const itemStatusSchema = z.enum(["backlog", "todo", "doing", "verifying", "done", "cancelled"]);
+export const prioritySchema = z.union([z.literal(0), z.literal(1), z.literal(2), z.literal(3), z.literal(4)]);
+export const listItemsFilterSchema = z.object({
+    projectId: z.string().optional(),
+    boardId: z.string().optional(),
+    status: itemStatusSchema.optional(),
+    kind: itemKindSchema.optional(),
+    workType: workTypeSchema.optional(),
+    priority: prioritySchema.optional(),
+    label: z.string().optional(),
+    parentId: z.string().nullable().optional(),
+    search: z.string().optional()
+});
+export const fieldValueSchema = z.union([z.string(), z.number()]);
+/** A key set to null clears the value. */
+export const fieldsPatchSchema = z.record(z.string(), fieldValueSchema.nullable());
+export const filterClauseSchema = z.object({
+    field: z.string(),
+    op: z.enum(["in", "not-in", "contains", "gte", "lte"]),
+    values: z.array(fieldValueSchema.nullable())
+});
+export const sortKeySchema = z.object({ field: z.string(), dir: z.enum(["asc", "desc"]) });
+export const createItemSchema = z.object({
+    playbookId: z.string().min(1).nullable().optional(),
+    title: z.string().min(1),
+    body: z.string().nullable().optional(),
+    kind: itemKindSchema.optional(),
+    workType: workTypeSchema.optional(),
+    status: itemStatusSchema.optional(),
+    priority: prioritySchema.optional(),
+    labels: z.array(z.string()).optional(),
+    parentId: z.string().nullable().optional(),
+    projectId: z.string().optional(),
+    boardId: z.string().optional(),
+    fields: fieldsPatchSchema.optional()
+});
+export const patchSchema = z.object({
+    playbookId: z.string().min(1).nullable().optional(),
+    title: z.string().optional(),
+    body: z.string().nullable().optional(),
+    kind: itemKindSchema.optional(),
+    workType: workTypeSchema.optional(),
+    status: itemStatusSchema.optional(),
+    priority: prioritySchema.optional(),
+    labels: z.array(z.string()).optional(),
+    blocks: z.array(z.string()).optional(),
+    parentId: z.string().nullable().optional(),
+    rank: z.number().optional(),
+    fields: fieldsPatchSchema.optional()
+});
+//# sourceMappingURL=schema.js.map

package/dist/types.d.ts

@@ -0,0 +1,302 @@
+import type { Layout, ViewQuery } from "./query.js";
+import type { TicketEvidence } from "./delivery.js";
+export type ItemKind = "ticket" | "epic";
+export type WorkType = "coding" | "general";
+export type ItemStatus = "backlog" | "todo" | "doing" | "verifying" | "done" | "cancelled";
+export declare const ITEM_STATUSES: readonly ItemStatus[];
+/** 0 None · 1 Low · 2 Medium (default) · 3 High · 4 Urgent. */
+export type Priority = 0 | 1 | 2 | 3 | 4;
+export declare const DEFAULT_PRIORITY: Priority;
+/** Who wrote a change. Human edits are 'human'; every agent or plugin write is 'ai:<source>'. */
+/** Who wrote: a person, a model, or a sync reading evidence in from outside (`sync:git` — a merge moved the ticket). */
+export type Author = "human" | `ai:${string}` | `sync:${string}`;
+/** Derived from updatedBy + humanLocked; never stored. */
+export type Provenance = "human" | "ai" | "sync" | "locked";
+/** A stored custom-field value. Dates are ISO `YYYY-MM-DD`; selects hold the option id. */
+export type FieldValue = string | number;
+export interface Item {
+    evidence: TicketEvidence;
+    id: string;
+    projectId: string;
+    /** The board that owns this issue. Dragging never changes it. */
+    boardId: string;
+    /** Per-project sequence behind the human key. Never reused. */
+    keyNum: number;
+    /** Display key, e.g. TOM-142. */
+    key: string;
+    title: string;
+    body: string | null;
+    kind: ItemKind;
+    workType: WorkType;
+    playbookId: string | null;
+    status: ItemStatus;
+    priority: Priority;
+    parentId: string | null;
+    rank: number;
+    labels: string[];
+    /** Ids of the items this one blocks. */
+    blocks: string[];
+    /** Ids of the items that block this one — the inverse of their `blocks`. */
+    blockedBy: string[];
+    /** Custom field values by field id. Built-in fields are the columns above. */
+    fields: Record<string, FieldValue>;
+    updatedAt: number;
+    updatedBy: Author;
+    version: number;
+    /** When set, AI writes may not touch title/body. */
+    humanLocked: boolean;
+}
+/** `fields` merges: a key set to null clears that value, absent keys are left alone. */
+export type Patch = Partial<Pick<Item, "title" | "body" | "kind" | "workType" | "playbookId" | "status" | "priority" | "parentId" | "rank" | "boardId" | "labels" | "blocks" | "humanLocked">> & {
+    fields?: Record<string, FieldValue | null>;
+};
+export type OplogEntity = "item" | "board" | "view";
+/**
+ * 'delete' is reversible — the row carries the snapshot undo restores from.
+ * 'purge' is a human-only permanent destroy: the entity's own history goes with
+ * it and the tombstone carries no snapshot, so undo walks straight past it.
+ * 'rank' is one item's manual position in one view — logged so it travels and
+ * can be undone, kept apart so history reads as decisions, not drags.
+ * 'merge' is a note a sync left behind: the same field changed on two machines,
+ * `before` holds the value that lost and `after` the one that stands. Undo
+ * steps over it; taking the loser back is an ordinary edit.
+ */
+export type OplogOp = "create" | "update" | "delete" | "purge" | "rank" | "merge";
+export interface OplogEntry {
+    seq: number;
+    entity: OplogEntity;
+    entityId: string;
+    op: OplogOp;
+    baseVersion: number | null;
+    before: unknown | null;
+    after: unknown | null;
+    by: Author;
+    at: number;
+    /** The agent run this write belongs to; null for a write made outside one. */
+    runId: string | null;
+    /** The machine that made the write; `device:deviceSeq` is the op's identity across machines. */
+    device: string;
+    /** The op's position in its own machine's sequence; null only for rows written before devices existed. */
+    deviceSeq: number | null;
+    /** The fields the op changed (the whole entity for a create); what the folder's log carries. */
+    patch: Record<string, unknown> | null;
+    /** The extension that made the write; null for the app itself. Local to this machine. */
+    via: string | null;
+}
+export interface UndoResult {
+    entry: OplogEntry;
+    /** One line describing what was reverted, for the toast. */
+    summary: string;
+}
+/** Result of reverting one agent run. `kept` names writes left in place because someone edited the entity afterwards. */
+export interface UndoRunResult {
+    reverted: number;
+    kept: {
+        entity: OplogEntity;
+        entityId: string;
+        label: string;
+        reason: string;
+    }[];
+}
+/**
+ * One record of the project's history as the timeline shows it: a backlog
+ * write, a file operation, or anything a plugin logs through its own undo
+ * provider. `ref` (`provider:id`) names it to `oplog.revert` and `oplog.rollback`.
+ */
+export interface UndoRecord {
+    ref: string;
+    provider: string;
+    id: string;
+    /** What kind of thing it touched: `item`, `board`, `view`, `file`, or a plugin's own. */
+    entity: string;
+    entityId: string;
+    /** What happened to it: an oplog op, or a file op (`write`, `mkdir`, `move`, `copy`, `remove`, `import`). */
+    op: string;
+    /** The entity's name for a sentence: an issue key, a view name, a file path. */
+    label: string;
+    /** A second name when the op has one — where a file moved or was copied to. */
+    target: string | null;
+    by: Author;
+    at: number;
+    runId: string | null;
+    /** The machine that made it; a record from another machine is history, never undoable here. */
+    device: string;
+    /** False for purges, merge notes and other machines' writes. */
+    undoable: boolean;
+    /** Set while the record sits in the redo stack; a new write anywhere clears that stack. */
+    undoneAt: number | null;
+}
+/** One step the timeline took: the record it acted on and a line for the toast. */
+export interface UndoStep {
+    record: UndoRecord;
+    summary: string;
+}
+/** Moving the timeline's cursor to a record: the steps taken, and why it stopped short when it did. */
+export interface RollbackResult {
+    steps: UndoStep[];
+    stopped: string | null;
+}
+export interface CreateItemInput {
+    projectId?: string;
+    boardId: string;
+    title: string;
+    body?: string | null;
+    kind?: ItemKind;
+    workType?: WorkType;
+    playbookId?: string | null;
+    status?: ItemStatus;
+    priority?: Priority;
+    parentId?: string | null;
+    rank?: number;
+    labels?: string[];
+    fields?: Record<string, FieldValue | null>;
+    by: Author;
+}
+export interface ListItemsFilter {
+    projectId?: string;
+    boardId?: string;
+    status?: ItemStatus;
+    kind?: ItemKind;
+    workType?: WorkType;
+    priority?: Priority;
+    parentId?: string | null;
+    label?: string;
+    /** Words that must all appear in title or body, as substrings in any script; matches come most relevant first. */
+    search?: string;
+    /** At most this many rows, from the front of the order: the most relevant when searching. */
+    limit?: number;
+    /** When no item has every search term, fall back to items with some of them, best matches first. */
+    widen?: boolean;
+}
+export interface Project {
+    id: string;
+    name: string;
+    description: string | null;
+    /** Prefix of the human issue key, e.g. 'TOM' in TOM-142. */
+    keyPrefix: string;
+    archived: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateProjectInput {
+    name: string;
+    description?: string | null;
+    keyPrefix?: string;
+}
+export type ProjectPatch = Partial<Pick<Project, "name" | "description" | "archived">>;
+/**
+ * A board is a workstream — an option of the built-in Workstream field. Every
+ * issue belongs to exactly one; a drag on a Workstream column writes it like
+ * any other field.
+ */
+export interface Board {
+    id: string;
+    projectId: string;
+    name: string;
+    icon: string;
+    note: string | null;
+    rank: number;
+    /** The code repository this workstream stands for, if any; several workstreams may share one. */
+    repoId: string | null;
+    /** Where in that repository the workstream's code lives; '' for the root. */
+    repoPath: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateBoardInput {
+    projectId: string;
+    name: string;
+    icon?: string;
+    note?: string | null;
+    rank?: number;
+    repoId?: string | null;
+    repoPath?: string;
+}
+export type BoardPatch = Partial<Pick<Board, "name" | "icon" | "note" | "rank" | "repoId" | "repoPath">>;
+/**
+ * A code repository a project's workstreams stand for. Shared: the remote URL
+ * is its identity everywhere. Where it is checked out on this machine is the
+ * catalog's business, never a row here.
+ */
+export interface Repo {
+    id: string;
+    projectId: string;
+    remote: string;
+    name: string;
+    defaultBranch: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateRepoInput {
+    projectId: string;
+    remote: string;
+    name?: string;
+    defaultBranch?: string;
+}
+export type RepoPatch = Partial<Pick<Repo, "name" | "defaultBranch" | "remote">>;
+/** A saved, named way of looking at the project's backlog: one layout and one query. */
+export interface View {
+    id: string;
+    projectId: string;
+    name: string;
+    icon: string;
+    layout: Layout;
+    query: ViewQuery;
+    rank: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateViewInput {
+    projectId: string;
+    name: string;
+    icon?: string;
+    layout?: Layout;
+    query?: Partial<ViewQuery>;
+    rank?: number;
+}
+export type ViewPatch = Partial<Pick<View, "name" | "icon" | "layout" | "query" | "rank">>;
+export type BuiltInTheme = "light" | "dark" | "matcha" | "dawn";
+export type ThemePreference = "system" | BuiltInTheme | `custom:${string}`;
+export declare const THEME_TOKEN_NAMES: readonly ["bg", "surface", "surface-warm", "fg", "fg-2", "muted", "meta", "border", "border-soft", "accent", "accent-on", "accent-light", "accent-active", "success", "warn", "danger", "tag-bg-faint", "tag-bg-soft", "tag-bg-base", "tag-bg-strong", "tag-fg"];
+export type ThemeTokenName = (typeof THEME_TOKEN_NAMES)[number];
+export declare const THEME_FONT_NAMES: readonly ["font-display", "font-body", "font-mono"];
+export type ThemeFontName = (typeof THEME_FONT_NAMES)[number];
+export declare const THEME_FONT_SIZE_NAMES: readonly ["text-xs", "text-sm", "text-base", "text-md", "text-lg", "text-xl", "text-2xl"];
+export declare const THEME_FONT_WEIGHT_NAMES: readonly ["font-weight-regular", "font-weight-medium"];
+export declare const THEME_TYPOGRAPHY_NAMES: readonly ["font-display", "font-body", "font-mono", "text-xs", "text-sm", "text-base", "text-md", "text-lg", "text-xl", "text-2xl", "font-weight-regular", "font-weight-medium"];
+export type ThemeTypographyName = (typeof THEME_TYPOGRAPHY_NAMES)[number];
+export interface CustomTheme {
+    id: `custom:${string}`;
+    name: string;
+    base: BuiltInTheme;
+    icon: "i-sun" | "i-moon" | "i-leaf" | "i-tag" | "i-bug" | "i-board" | "i-stack" | "i-sliders";
+    tokens: Record<ThemeTokenName, string>;
+    fonts: Record<ThemeTypographyName, string>;
+}
+export type ThemeAutomationMode = "none" | "system" | "schedule" | "shuffle";
+export interface ThemeScheduleRule {
+    start: string;
+    end: string;
+    theme: Exclude<ThemePreference, "system">;
+}
+export interface ThemeAutomation {
+    mode: ThemeAutomationMode;
+    defaultTheme: Exclude<ThemePreference, "system">;
+    schedule: ThemeScheduleRule[];
+    shuffleMinutes: number;
+}
+/** 'system' follows the OS locale, falling back to English when that locale isn't supported. */
+export type LanguagePreference = "system" | "en" | "zh";
+export interface LlmSettings {
+    apiKey: string;
+    baseURL: string;
+    model: string;
+}
+/** Settings are sections keyed by id; plugins register their own. */
+export interface AppSettings {
+    theme: ThemePreference;
+    language: LanguagePreference;
+    llm?: LlmSettings;
+    [section: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,8 @@
+export const ITEM_STATUSES = ["backlog", "todo", "doing", "verifying", "done", "cancelled"];
+export const DEFAULT_PRIORITY = 2;
+export const THEME_TOKEN_NAMES = ["bg", "surface", "surface-warm", "fg", "fg-2", "muted", "meta", "border", "border-soft", "accent", "accent-on", "accent-light", "accent-active", "success", "warn", "danger", "tag-bg-faint", "tag-bg-soft", "tag-bg-base", "tag-bg-strong", "tag-fg"];
+export const THEME_FONT_NAMES = ["font-display", "font-body", "font-mono"];
+export const THEME_FONT_SIZE_NAMES = ["text-xs", "text-sm", "text-base", "text-md", "text-lg", "text-xl", "text-2xl"];
+export const THEME_FONT_WEIGHT_NAMES = ["font-weight-regular", "font-weight-medium"];
+export const THEME_TYPOGRAPHY_NAMES = [...THEME_FONT_NAMES, ...THEME_FONT_SIZE_NAMES, ...THEME_FONT_WEIGHT_NAMES];
+//# sourceMappingURL=types.js.map

package/dist/view-kinds.d.ts

@@ -0,0 +1,13 @@
+import type { GroupBy, ViewKind } from "./types.js";
+/**
+ * The `views` table still carries legacy `name`/`icon`/`group_by` columns
+ * (kept for schema stability — see packages/db). These are the values written
+ * into them for each built-in kind; the app itself never reads them back.
+ */
+export declare const VIEW_KIND_META: Record<ViewKind, {
+    name: string;
+    icon: string;
+    groupBy: GroupBy;
+    rank: number;
+}>;
+//# sourceMappingURL=view-kinds.d.ts.map

package/dist/view-kinds.js

@@ -0,0 +1,12 @@
+/**
+ * The `views` table still carries legacy `name`/`icon`/`group_by` columns
+ * (kept for schema stability — see packages/db). These are the values written
+ * into them for each built-in kind; the app itself never reads them back.
+ */
+export const VIEW_KIND_META = {
+    status: { name: "Status", icon: "s-doing", groupBy: "status", rank: 0 },
+    priority: { name: "Priority", icon: "i-bars", groupBy: "priority", rank: 1 },
+    epic: { name: "Epic", icon: "i-stack", groupBy: "epic", rank: 2 },
+    dependencies: { name: "Dependencies", icon: "i-graph", groupBy: "status", rank: 3 }
+};
+//# sourceMappingURL=view-kinds.js.map