kanbo-cli 0.2.1 → 0.3.0

package/dist/lib/{migrate-BhYi9cXw.mjs → migrate-DtBeW3Fs.mjs}

@@ -1,11 +1,22 @@
-import { a as BoardError, i as BOARD_TABLES_ADDED_WITHIN_EPOCH, n as resolveBoardMigrationsPath, t as hasMigrationJournal } from "./migrations-path-Ciwan537.mjs";
+import { a as BoardError, i as BOARD_TABLES_ADDED_WITHIN_EPOCH, n as resolveBoardMigrationsPath, t as hasMigrationJournal } from "./migrations-path-ClaYRNwk.mjs";
 import { boardSqliteSchema, issueComments, issueFieldChanges, issueMilestones, issuePullRequests, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta } from "./sqlite/schema.mjs";
 import { createRequire } from "node:module";
-import { and, asc, desc, eq, getTableColumns, inArray, isNotNull, or, sql } from "drizzle-orm";
+import { and, asc, desc, eq, getTableColumns, gte, inArray, isNotNull, isNull, or, sql } from "drizzle-orm";
 import { getTableConfig } from "drizzle-orm/sqlite-core";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+//#region src/domain/fold-case.ts
+/**
+* Text as a search compares it: every letter lowercased by Unicode's rules, not
+* only A–Z — `Über` and `über` are one word. What Postgres `ilike` does on
+* either side of a board search; SQLite's own `like` folds ASCII alone, so a
+* board file compares through this function instead (`kanbo_fold`).
+*/
+function foldCase(text) {
+	return text.toLowerCase();
+}
+//#endregion
 //#region src/sqlite/transaction.ts
 /**
 * The better-sqlite3 handle Drizzle keeps beside the query builder. `drizzle()`
@@ -162,6 +173,82 @@ function selectRunProjection(database, scope) {
 	}));
 }
 /**
+* One page of the cards a query picks, and how many it picks in all, in one
+* statement: `count(*) over ()` is taken over every picked row before `limit`
+* and `offset` cut the page out of them. Only a page past the last card — no
+* row to carry the count — asks a second time.
+*/
+function selectCardPage(database, query) {
+	if (query.statusIds?.length === 0 || query.priorities?.length === 0) return {
+		cards: [],
+		total: 0
+	};
+	if (query.text !== void 0) registerFoldFunction(database);
+	const where = and(...cardQueryPredicates(query));
+	const rows = database.select({
+		...getTableColumns(issues),
+		pickedTotal: sql`count(*) over ()`
+	}).from(issues).where(where).orderBy(issues.order, desc(issues.createdAt), issues.id).limit(query.limit ?? Number.MAX_SAFE_INTEGER).offset(query.offset ?? 0).all();
+	if (rows.length === 0) return {
+		cards: [],
+		total: (query.offset ?? 0) > 0 ? database.select({ count: sql`count(*)` }).from(issues).where(where).get()?.count ?? 0 : 0
+	};
+	return {
+		cards: rows.map(({ pickedTotal: _total, ...card }) => card),
+		total: rows[0].pickedTotal
+	};
+}
+/** The connections `kanbo_fold` is registered on already. */
+const foldingConnections = /* @__PURE__ */ new WeakSet();
+/**
+* Teach the connection `kanbo_fold(text)`, the search's `foldCase`, once.
+*
+* SQLite's `like` and `lower()` fold A–Z and nothing else, so `über` would not
+* find `Über` on a board file while Postgres `ilike` and the HTTP transport find
+* it. The function is registered on the connection the statement runs on —
+* the host may have opened it, not this package — and stays one statement.
+*/
+function registerFoldFunction(database) {
+	const connection = readSqliteConnection(database);
+	if (foldingConnections.has(connection)) return;
+	connection.function("kanbo_fold", { deterministic: true }, (value) => typeof value === "string" ? foldCase(value) : value);
+	foldingConnections.add(connection);
+}
+function cardQueryPredicates(query) {
+	const running = sql`${issues.id} in (select ${issueRuns.issueId} from ${issueRuns} where ${issueRuns.state} = 'running')`;
+	const text = foldCase(query.text ?? "");
+	return [
+		eq(issues.workspaceId, query.workspaceId),
+		query.statusIds === void 0 ? void 0 : inArray(issues.statusId, [...query.statusIds]),
+		query.waitingForPerson === void 0 ? void 0 : query.waitingForPerson ? eq(issues.waitingFor, "human") : isNull(issues.waitingFor),
+		query.parentIssueId === void 0 ? void 0 : eq(issues.parentIssueId, query.parentIssueId),
+		query.hasActiveRun === void 0 ? void 0 : query.hasActiveRun ? running : sql`not ${running}`,
+		query.returned === void 0 ? void 0 : query.returned ? returnedCard(running) : sql`not ${returnedCard(running)}`,
+		query.text === void 0 ? void 0 : sql`(instr(kanbo_fold(${issues.id}), ${text}) > 0 or instr(kanbo_fold(${issues.title}), ${text}) > 0 or instr(kanbo_fold(coalesce(${issues.description}, '')), ${text}) > 0)`,
+		query.updatedSince === void 0 ? void 0 : gte(issues.updatedAt, query.updatedSince),
+		...(query.labels ?? []).map((label) => sql`exists (select 1 from json_each(${issues.labels}) where value = ${label})`),
+		query.priorities === void 0 ? void 0 : inArray(issues.priority, [...query.priorities])
+	];
+}
+/**
+* A card a person sent back that nobody picked up again (`BoardCardQuery.returned`):
+* not waiting, not running, and its last decision a return — no approval or
+* return written after it, `rowid` breaking a tie inside one second the way
+* `readApproval`'s comment order does.
+*/
+function returnedCard(running) {
+	return sql`(${issues.waitingFor} is null and not ${running} and exists (
+    select 1 from ${issueComments} as decision
+    where decision.issue_id = ${issues.id} and decision.author_kind = 'system.returned'
+      and not exists (
+        select 1 from ${issueComments} as later
+        where later.issue_id = decision.issue_id
+          and later.author_kind in ('system.approved', 'system.returned')
+          and (later.created_at > decision.created_at or (later.created_at = decision.created_at and later.rowid > decision.rowid))
+      )
+  ))`;
+}
+/**
 * Bind the store's statements to one SQLite handle. `resolveDatabase` is called
 * per statement rather than captured, so the store follows a host that swaps its
 * database out (a server that resets its infrastructure between tests, say).
@@ -173,6 +260,7 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 			listAllInBoardOrder: () => resolveDatabase().select().from(issueStatuses).orderBy(issueStatuses.workspaceId, issueStatuses.order).all(),
 			listAll: () => resolveDatabase().select().from(issueStatuses).all(),
 			findById: (statusId) => resolveDatabase().select().from(issueStatuses).where(eq(issueStatuses.id, statusId)).get() ?? null,
+			lockById: (statusId) => resolveDatabase().select().from(issueStatuses).where(eq(issueStatuses.id, statusId)).get() ?? null,
 			findInWorkspace: (workspaceId, statusId) => resolveDatabase().select().from(issueStatuses).where(sql`${issueStatuses.workspaceId} = ${workspaceId} AND ${issueStatuses.id} = ${statusId}`).get() ?? null,
 			countByWorkspace: (workspaceId) => {
 				return resolveDatabase().select({ count: sql`count(*)` }).from(issueStatuses).where(eq(issueStatuses.workspaceId, workspaceId)).get()?.count ?? 0;
@@ -205,11 +293,17 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 		issues: {
 			listInBoardOrder: (workspaceId) => {
 				const predicates = [workspaceId ? eq(issues.workspaceId, workspaceId) : void 0].filter((predicate) => predicate !== void 0);
-				return resolveDatabase().select().from(issues).where(predicates.length > 0 ? and(...predicates) : void 0).orderBy(issues.order, desc(issues.createdAt)).all();
+				return resolveDatabase().select().from(issues).where(predicates.length > 0 ? and(...predicates) : void 0).orderBy(issues.order, desc(issues.createdAt), issues.id).all();
 			},
 			listNewestFirst: () => resolveDatabase().select().from(issues).orderBy(desc(issues.createdAt)).all(),
 			listAll: () => resolveDatabase().select().from(issues).all(),
 			listByWorkspace: (workspaceId) => resolveDatabase().select().from(issues).where(eq(issues.workspaceId, workspaceId)).all(),
+			listPage: (query) => selectCardPage(resolveDatabase(), query),
+			countByMilestone: (workspaceId) => resolveDatabase().select({
+				milestoneId: sql`${issues.milestoneId}`,
+				statusId: issues.statusId,
+				count: sql`count(*)`
+			}).from(issues).where(and(eq(issues.workspaceId, workspaceId), isNotNull(issues.milestoneId))).groupBy(issues.milestoneId, issues.statusId).all(),
 			listByIds: (issueIds) => resolveDatabase().select().from(issues).where(inArray(issues.id, issueIds)).all(),
 			findById: (issueId) => resolveDatabase().select().from(issues).where(eq(issues.id, issueId)).get() ?? null,
 			findInWorkspace: (workspaceId, issueId) => resolveDatabase().select().from(issues).where(and(eq(issues.id, issueId), eq(issues.workspaceId, workspaceId))).get() ?? null,
@@ -248,6 +342,15 @@ function createSqliteBoardStoreCore(resolveDatabase) {
 		},
 		comments: {
 			listByIssue: (issueId) => resolveDatabase().select().from(issueComments).where(eq(issueComments.issueId, issueId)).orderBy(asc(issueComments.createdAt), COMMENT_INSERTION_ORDER).all(),
+			listLatestByIssues: (issueIds, authorKinds) => {
+				if (issueIds.length === 0 || authorKinds?.length === 0) return [];
+				const database = resolveDatabase();
+				const ranked = database.select({
+					id: issueComments.id,
+					commentRank: sql`row_number() over (partition by ${issueComments.issueId} order by ${issueComments.createdAt} desc, ${issueComments}.rowid desc)`.as("comment_rank")
+				}).from(issueComments).where(and(inArray(issueComments.issueId, [...issueIds]), authorKinds === void 0 ? void 0 : inArray(issueComments.authorKind, [...authorKinds]))).as("ranked");
+				return database.select(getTableColumns(issueComments)).from(issueComments).innerJoin(ranked, eq(ranked.id, issueComments.id)).where(eq(ranked.commentRank, 1)).all();
+			},
 			findById: (commentId) => resolveDatabase().select().from(issueComments).where(eq(issueComments.id, commentId)).get() ?? null,
 			findByDedupeKey: (issueId, dedupeKey) => resolveDatabase().select().from(issueComments).where(and(eq(issueComments.issueId, issueId), eq(issueComments.dedupeKey, dedupeKey))).get() ?? null,
 			listByDedupeKeyPrefix: (issueId, prefix) => resolveDatabase().select().from(issueComments).where(and(eq(issueComments.issueId, issueId), sql`substr(${issueComments.dedupeKey}, 1, ${prefix.length}) = ${prefix}`)).orderBy(asc(issueComments.createdAt), COMMENT_INSERTION_ORDER).all(),
@@ -354,6 +457,7 @@ function createSqliteBoardStore(options) {
 			listAllInBoardOrder: async () => core.statuses.listAllInBoardOrder(),
 			listAll: async () => core.statuses.listAll(),
 			findById: async (statusId) => core.statuses.findById(statusId),
+			lockById: async (statusId) => core.statuses.lockById(statusId),
 			findInWorkspace: async (workspaceId, statusId) => core.statuses.findInWorkspace(workspaceId, statusId),
 			countByWorkspace: async (workspaceId) => core.statuses.countByWorkspace(workspaceId),
 			create: async (values) => core.statuses.create(values),
@@ -375,6 +479,8 @@ function createSqliteBoardStore(options) {
 			listNewestFirst: async () => core.issues.listNewestFirst(),
 			listAll: async () => core.issues.listAll(),
 			listByWorkspace: async (workspaceId) => core.issues.listByWorkspace(workspaceId),
+			listPage: async (query) => core.issues.listPage(query),
+			countByMilestone: async (workspaceId) => core.issues.countByMilestone(workspaceId),
 			listByIds: async (issueIds) => core.issues.listByIds(issueIds),
 			findById: async (issueId) => core.issues.findById(issueId),
 			findInWorkspace: async (workspaceId, issueId) => core.issues.findInWorkspace(workspaceId, issueId),
@@ -391,6 +497,7 @@ function createSqliteBoardStore(options) {
 		},
 		comments: {
 			listByIssue: async (issueId) => core.comments.listByIssue(issueId),
+			listLatestByIssues: async (issueIds, authorKinds) => core.comments.listLatestByIssues(issueIds, authorKinds),
 			findById: async (commentId) => core.comments.findById(commentId),
 			findByDedupeKey: async (issueId, dedupeKey) => core.comments.findByDedupeKey(issueId, dedupeKey),
 			listByDedupeKeyPrefix: async (issueId, prefix) => core.comments.listByDedupeKeyPrefix(issueId, prefix),
@@ -448,25 +555,35 @@ function createSqliteBoardStore(options) {
 	};
 	return store;
 }
+/** The logger a board handle is opened with: the counter while one is on, otherwise none. */
+function boardQueryLogger() {}
 //#endregion
 //#region src/sqlite/open-database.ts
 const require = createRequire(import.meta.url);
 /** The tables a board file must already carry for this package to read it. */
 const REQUIRED_BOARD_TABLES = ["issue_runs", "kanban_meta"];
-/** What a caller is told when the native module a board file needs is not installed. */
-const BETTER_SQLITE3_MISSING_MESSAGE = "Install better-sqlite3 to use a board file";
 /**
-* `better-sqlite3` is an optional peer dependency (ruling 5): a Postgres-only
-* or capabilities-only install carries no native module, and importing
-* `kanbo/sqlite` for a type or for `runSqliteTransaction` should not
-* demand one either. So the require happens here, the one place a board file
-* is actually opened, rather than at the top of this module.
+* What a caller is told when the native module a board file needs does not
+* load: which Node, system and processor it was tried on — a prebuilt module
+* exists for most, not all — what the loader said, and how to get it back.
+*/
+function betterSqlite3MissingMessage(cause) {
+	const said = cause instanceof Error ? cause.message.split("\n")[0] : String(cause);
+	return `Could not load better-sqlite3, which kanbo opens board files with, on Node ${process.version} (${process.platform}-${process.arch}): ${said}. Reinstall kanbo with npm install -g kanbo-cli, which brings it along; a program that uses kanbo as a library installs better-sqlite3 itself.`;
+}
+/**
+* `better-sqlite3` is an optional dependency (ruling 5): an install where it
+* could not be built carries no native module, and a Postgres-only or
+* capabilities-only use — or importing `kanbo/sqlite` for a type or for
+* `runSqliteTransaction` — should not demand one. So the require happens here,
+* the one place a board file is actually opened, rather than at the top of
+* this module.
 */
 function loadBetterSqlite3() {
 	try {
 		return require("better-sqlite3");
 	} catch (error) {
-		throw new Error(BETTER_SQLITE3_MISSING_MESSAGE, { cause: error });
+		throw new Error(betterSqlite3MissingMessage(error), { cause: error });
 	}
 }
 /**
@@ -479,7 +596,7 @@ function loadBetterSqlite3() {
 * this module, `kanbo capabilities` and `kanbo/mcp` included, and the
 * friendly message above becomes unreachable. A dynamic import keeps the whole
 * chain behind the one call that actually opens a file, which is what makes the
-* optional peer honest. `createRequire` would be the smaller change and is the
+* optional dependency honest. `createRequire` would be the smaller change and is the
 * wrong one: it would load drizzle's CJS copy beside the ESM one this package
 * already holds, and it would resolve from `node_modules`, which the packaged
 * `dist/cli.cjs` deliberately does not have beside it.
@@ -512,7 +629,10 @@ async function openBoardDatabase(path) {
 	connection.pragma("busy_timeout = 5000");
 	connection.pragma("synchronous = NORMAL");
 	return {
-		database: drizzle(connection, { schema: boardSqliteSchema }),
+		database: drizzle(connection, {
+			schema: boardSqliteSchema,
+			logger: void 0
+		}),
 		connection,
 		close: () => connection.close()
 	};
@@ -651,6 +771,4 @@ function migrateBoardFile(database) {
 	migrate(database, { migrationsFolder: getBoardSqliteMigrationsPath() });
 }
 //#endregion
-export { openBoardDatabase as a, createSqliteBoardStore as c, markBoardFileOwnedByKanbo as i, runSqliteTransaction as l, migrateBoardFile as n, readBoardFileContents as o, assertBoardSchema as r, readBoardFileOwner as s, getBoardSqliteMigrationsPath as t };
-
-//# sourceMappingURL=migrate-BhYi9cXw.mjs.map
+export { openBoardDatabase as a, boardQueryLogger as c, foldCase as d, markBoardFileOwnedByKanbo as i, createSqliteBoardStore as l, migrateBoardFile as n, readBoardFileContents as o, assertBoardSchema as r, readBoardFileOwner as s, getBoardSqliteMigrationsPath as t, runSqliteTransaction as u };

package/dist/lib/{migrations-path-Ciwan537.mjs → migrations-path-ClaYRNwk.mjs}

@@ -44,9 +44,9 @@ const BOARD_TABLES_ADDED_WITHIN_EPOCH = ["issue_pull_requests"];
 * The folder is found relative to the file asking for it, because the same code
 * runs from two layouts: from `src/<dialect>/` in a checkout, where the folder
 * sits at the package root, and from `dist/cli.cjs` in an installed build, where
-* the build has copied it in beside the bundle. The packaged command ships no
-* `node_modules` and no package root — `dist/` is the whole of it — so the copy
-* is the only migrations folder there is.
+* the build has copied it in beside the bundle. The npm tarball and the packaged
+* command alike ship only that copy — `dist/` is the whole of it — so it is the
+* only migrations folder an installed kanbo has.
 *
 * Kept apart from the migrators on purpose: this is a packaging question, and
 * two dialects ask it about two folders. The caller passes its own `here`, so
@@ -57,7 +57,7 @@ const JOURNAL_FILE = join("meta", "_journal.json");
 /**
 * The first of the layouts that is actually there, as seen from `here`.
 *
-* Pure, and takes its own `exists`, so all three layouts can be asked about on
+* Pure, and takes its own `exists`, so every layout can be asked about on
 * a machine that only has one of them. When none is there the source layout is
 * handed back, so the migrator's complaint names the folder a developer is
 * missing rather than one that only exists inside a packaged app.
@@ -66,7 +66,7 @@ function resolveBoardMigrationsPath(here, directory, exists) {
 	const candidates = [
 		join(here, "..", "..", directory),
 		join(here, directory),
-		join(here, "..", "..", "..", directory)
+		join(here, "..", directory)
 	];
 	return candidates.find(exists) ?? candidates[0];
 }
@@ -76,5 +76,3 @@ function hasMigrationJournal(folder) {
 }
 //#endregion
 export { BoardError as a, BOARD_TABLES_ADDED_WITHIN_EPOCH as i, resolveBoardMigrationsPath as n, BOARD_SCHEMA_EPOCH as r, hasMigrationJournal as t };
-
-//# sourceMappingURL=migrations-path-Ciwan537.mjs.map

package/dist/lib/{migrations-path-CZxVOgeD.cjs → migrations-path-DBCE17dT.cjs}

@@ -44,9 +44,9 @@ const BOARD_TABLES_ADDED_WITHIN_EPOCH = ["issue_pull_requests"];
 * The folder is found relative to the file asking for it, because the same code
 * runs from two layouts: from `src/<dialect>/` in a checkout, where the folder
 * sits at the package root, and from `dist/cli.cjs` in an installed build, where
-* the build has copied it in beside the bundle. The packaged command ships no
-* `node_modules` and no package root — `dist/` is the whole of it — so the copy
-* is the only migrations folder there is.
+* the build has copied it in beside the bundle. The npm tarball and the packaged
+* command alike ship only that copy — `dist/` is the whole of it — so it is the
+* only migrations folder an installed kanbo has.
 *
 * Kept apart from the migrators on purpose: this is a packaging question, and
 * two dialects ask it about two folders. The caller passes its own `here`, so
@@ -57,7 +57,7 @@ const JOURNAL_FILE = (0, node_path.join)("meta", "_journal.json");
 /**
 * The first of the layouts that is actually there, as seen from `here`.
 *
-* Pure, and takes its own `exists`, so all three layouts can be asked about on
+* Pure, and takes its own `exists`, so every layout can be asked about on
 * a machine that only has one of them. When none is there the source layout is
 * handed back, so the migrator's complaint names the folder a developer is
 * missing rather than one that only exists inside a packaged app.
@@ -66,7 +66,7 @@ function resolveBoardMigrationsPath(here, directory, exists) {
 	const candidates = [
 		(0, node_path.join)(here, "..", "..", directory),
 		(0, node_path.join)(here, directory),
-		(0, node_path.join)(here, "..", "..", "..", directory)
+		(0, node_path.join)(here, "..", directory)
 	];
 	return candidates.find(exists) ?? candidates[0];
 }
@@ -105,5 +105,3 @@ Object.defineProperty(exports, "resolveBoardMigrationsPath", {
 		return resolveBoardMigrationsPath;
 	}
 });
-
-//# sourceMappingURL=migrations-path-CZxVOgeD.cjs.map

package/dist/lib/postgres/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_migrations_path = require("../migrations-path-CZxVOgeD.cjs");
-const require_roles_sql = require("../roles.sql-B9rt-x4o.cjs");
+const require_migrations_path = require("../migrations-path-DBCE17dT.cjs");
+const require_roles_sql = require("../roles.sql-E58x7mLS.cjs");
 let drizzle_orm = require("drizzle-orm");
 let drizzle_orm_postgres_js_migrator = require("drizzle-orm/postgres-js/migrator");
 let drizzle_orm_pglite_migrator = require("drizzle-orm/pglite/migrator");
@@ -52,5 +52,3 @@ exports.issueStatuses = require_roles_sql.issueStatuses;
 exports.issues = require_roles_sql.issues;
 exports.kanbanMeta = require_roles_sql.kanbanMeta;
 exports.migrateBoardDatabase = migrateBoardDatabase;
-
-//# sourceMappingURL=index.cjs.map

package/dist/lib/postgres/index.d.cts

@@ -1,4 +1,4 @@
-import { a as BoardStore } from "../board-store-BfszzAJB.cjs";
+import { c as BoardStore } from "../board-store-Dx-mw2I6.cjs";
 import { t as BOARD_SCHEMA_EPOCH } from "../schema-epoch-ZyumVL_A.cjs";
 import { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
 import { PgliteDatabase } from "drizzle-orm/pglite";
@@ -3399,5 +3399,4 @@ export declare const boardPostgresSchema: {
 /** The table names a Postgres board must carry, for the guard that refuses a database without them. */
 export declare const BOARD_POSTGRES_TABLES: readonly ['issue_statuses', 'issue_milestones', 'issues', 'issue_comments', 'issue_runs', 'issue_relations', 'issue_field_changes', 'issue_pull_requests', 'kanban_meta'];
 //#endregion
-export { BOARD_SCHEMA_EPOCH, type BoardPostgresDatabase, type MigratablePostgresDatabase };
-//# sourceMappingURL=index.d.cts.map
+export { BOARD_SCHEMA_EPOCH, type BoardPostgresDatabase, type MigratablePostgresDatabase };

package/dist/lib/postgres/index.d.mts

@@ -1,4 +1,4 @@
-import { a as BoardStore } from "../board-store-BvWn9xTB.mjs";
+import { c as BoardStore } from "../board-store-D_Mpfb84.mjs";
 import { t as BOARD_SCHEMA_EPOCH } from "../schema-epoch-ZyumVL_A.mjs";
 import { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
@@ -3399,5 +3399,4 @@ export declare const boardPostgresSchema: {
 /** The table names a Postgres board must carry, for the guard that refuses a database without them. */
 export declare const BOARD_POSTGRES_TABLES: readonly ['issue_statuses', 'issue_milestones', 'issues', 'issue_comments', 'issue_runs', 'issue_relations', 'issue_field_changes', 'issue_pull_requests', 'kanban_meta'];
 //#endregion
-export { BOARD_SCHEMA_EPOCH, type BoardPostgresDatabase, type MigratablePostgresDatabase };
-//# sourceMappingURL=index.d.mts.map
+export { BOARD_SCHEMA_EPOCH, type BoardPostgresDatabase, type MigratablePostgresDatabase };

package/dist/lib/postgres/index.mjs

@@ -1,5 +1,5 @@
-import { r as BOARD_SCHEMA_EPOCH } from "../migrations-path-Ciwan537.mjs";
-import { _ as issueStatuses, a as BOARD_REFUSAL_ERRCODE, c as getBoardMigrationsPath, d as boardPostgresSchema, f as issueComments, g as issueRuns, h as issueRelations, i as BOARD_PERSON_ROLE, l as createPostgresBoardStore, m as issueMilestones, n as AGENT_WAITING_REFUSAL, o as BOARD_ROLE_SQL, p as issueFieldChanges, r as BOARD_AGENT_ROLE, s as assertBoardSchema, t as AGENT_APPROVAL_COMMENT_REFUSAL, u as BOARD_POSTGRES_TABLES, v as issues, y as kanbanMeta } from "../roles.sql-CvyCGt38.mjs";
+import { r as BOARD_SCHEMA_EPOCH } from "../migrations-path-ClaYRNwk.mjs";
+import { _ as issueStatuses, a as BOARD_REFUSAL_ERRCODE, c as getBoardMigrationsPath, d as boardPostgresSchema, f as issueComments, g as issueRuns, h as issueRelations, i as BOARD_PERSON_ROLE, l as createPostgresBoardStore, m as issueMilestones, n as AGENT_WAITING_REFUSAL, o as BOARD_ROLE_SQL, p as issueFieldChanges, r as BOARD_AGENT_ROLE, s as assertBoardSchema, t as AGENT_APPROVAL_COMMENT_REFUSAL, u as BOARD_POSTGRES_TABLES, v as issues, y as kanbanMeta } from "../roles.sql-BoOZSkBp.mjs";
 import { entityKind } from "drizzle-orm";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import { migrate as migrate$1 } from "drizzle-orm/pglite/migrator";
@@ -31,5 +31,3 @@ function isPgliteDatabase(database) {
 }
 //#endregion
 export { AGENT_APPROVAL_COMMENT_REFUSAL, AGENT_WAITING_REFUSAL, BOARD_AGENT_ROLE, BOARD_PERSON_ROLE, BOARD_POSTGRES_TABLES, BOARD_REFUSAL_ERRCODE, BOARD_ROLE_SQL, BOARD_SCHEMA_EPOCH, assertBoardSchema, boardPostgresSchema, createPostgresBoardStore, getBoardMigrationsPath, issueComments, issueFieldChanges, issueMilestones, issueRelations, issueRuns, issueStatuses, issues, kanbanMeta, migrateBoardDatabase };
-
-//# sourceMappingURL=index.mjs.map

package/dist/lib/{roles.sql-CvyCGt38.mjs → roles.sql-BoOZSkBp.mjs}

@@ -1,8 +1,18 @@
-import { a as BoardError, i as BOARD_TABLES_ADDED_WITHIN_EPOCH, n as resolveBoardMigrationsPath, t as hasMigrationJournal } from "./migrations-path-Ciwan537.mjs";
-import { and, asc, desc, eq, getTableColumns, inArray, isNotNull, or, sql } from "drizzle-orm";
+import { a as BoardError, i as BOARD_TABLES_ADDED_WITHIN_EPOCH, n as resolveBoardMigrationsPath, t as hasMigrationJournal } from "./migrations-path-ClaYRNwk.mjs";
+import { and, asc, desc, eq, getTableColumns, gte, inArray, isNotNull, isNull, or, sql } from "drizzle-orm";
 import { bigint, bigserial, getTableConfig, index, integer, pgSchema, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+//#region src/domain/like-pattern.ts
+/**
+* A `like` pattern that finds `text` anywhere in a value, the text matched as
+* written: `%`, `_` and the escape character itself are escaped with `\`, the
+* character a statement names in `escape '\'`.
+*/
+function containsLikePattern(text) {
+	return `%${text.replace(/[\\%_]/g, (character) => `\\${character}`)}%`;
+}
+//#endregion
 //#region src/postgres/schema.ts
 /**
 * The board, as a Postgres database holds it.
@@ -348,6 +358,71 @@ async function selectRunProjection(database, scope) {
 	}));
 }
 /**
+* One page of the cards a query picks, and how many it picks in all, in one
+* statement — the SQLite store's read, with the count cast to `int` (Postgres
+* counts in `bigint`) and text matched with `ilike`, which folds every letter.
+*/
+async function selectCardPage(database, query) {
+	if (query.statusIds?.length === 0 || query.priorities?.length === 0) return {
+		cards: [],
+		total: 0
+	};
+	const where = and(...cardQueryPredicates(query));
+	const page = database.select({
+		...getTableColumns(issues),
+		pickedTotal: sql`cast(count(*) over () as int)`
+	}).from(issues).where(where).orderBy(issues.order, desc(issues.createdAt), issues.id).offset(query.offset ?? 0).$dynamic();
+	const rows = await (query.limit === void 0 ? page : page.limit(query.limit));
+	if (rows.length === 0) {
+		if ((query.offset ?? 0) === 0) return {
+			cards: [],
+			total: 0
+		};
+		const [row] = await database.select({ count: sql`cast(count(*) as int)` }).from(issues).where(where);
+		return {
+			cards: [],
+			total: row?.count ?? 0
+		};
+	}
+	return {
+		cards: rows.map(({ pickedTotal: _total, ...card }) => card),
+		total: rows[0].pickedTotal
+	};
+}
+function cardQueryPredicates(query) {
+	const running = sql`${issues.id} in (select ${issueRuns.issueId} from ${issueRuns} where ${issueRuns.state} = 'running')`;
+	const pattern = containsLikePattern(query.text ?? "");
+	return [
+		eq(issues.workspaceId, query.workspaceId),
+		query.statusIds === void 0 ? void 0 : inArray(issues.statusId, [...query.statusIds]),
+		query.waitingForPerson === void 0 ? void 0 : query.waitingForPerson ? eq(issues.waitingFor, "human") : isNull(issues.waitingFor),
+		query.parentIssueId === void 0 ? void 0 : eq(issues.parentIssueId, query.parentIssueId),
+		query.hasActiveRun === void 0 ? void 0 : query.hasActiveRun ? running : sql`not ${running}`,
+		query.returned === void 0 ? void 0 : query.returned ? returnedCard(running) : sql`not ${returnedCard(running)}`,
+		query.text === void 0 ? void 0 : sql`(${issues.id} ilike ${pattern} escape '\\' or ${issues.title} ilike ${pattern} escape '\\' or coalesce(${issues.description}, '') ilike ${pattern} escape '\\')`,
+		query.updatedSince === void 0 ? void 0 : gte(issues.updatedAt, query.updatedSince),
+		...(query.labels ?? []).map((label) => sql`cast(${issues.labels} as jsonb) @> cast(${JSON.stringify([label])} as jsonb)`),
+		query.priorities === void 0 ? void 0 : inArray(issues.priority, [...query.priorities])
+	];
+}
+/**
+* A card a person sent back that nobody picked up again (`BoardCardQuery.returned`):
+* not waiting, not running, and its last decision a return — `seq` breaking a
+* tie inside one second where SQLite reads `rowid`.
+*/
+function returnedCard(running) {
+	return sql`(${issues.waitingFor} is null and not ${running} and exists (
+    select 1 from ${issueComments} as decision
+    where decision.issue_id = ${issues.id} and decision.author_kind = 'system.returned'
+      and not exists (
+        select 1 from ${issueComments} as later
+        where later.issue_id = decision.issue_id
+          and later.author_kind in ('system.approved', 'system.returned')
+          and (later.created_at > decision.created_at or (later.created_at = decision.created_at and later.seq > decision.seq))
+      )
+  ))`;
+}
+/**
 * The board's statements against one Postgres handle — a connection, or a
 * transaction on one.
 *
@@ -365,6 +440,10 @@ function createStoreOver(database) {
 				const [row] = await database.select().from(issueStatuses).where(eq(issueStatuses.id, statusId)).limit(1);
 				return row ?? null;
 			},
+			lockById: async (statusId) => {
+				const [row] = await database.select().from(issueStatuses).where(eq(issueStatuses.id, statusId)).limit(1).for("update");
+				return row ?? null;
+			},
 			findInWorkspace: async (workspaceId, statusId) => {
 				const [row] = await database.select().from(issueStatuses).where(and(eq(issueStatuses.workspaceId, workspaceId), eq(issueStatuses.id, statusId))).limit(1);
 				return row ?? null;
@@ -408,10 +487,16 @@ function createStoreOver(database) {
 			}
 		},
 		issues: {
-			listInBoardOrder: async (workspaceId) => await database.select().from(issues).where(workspaceId ? eq(issues.workspaceId, workspaceId) : void 0).orderBy(issues.order, desc(issues.createdAt)),
+			listInBoardOrder: async (workspaceId) => await database.select().from(issues).where(workspaceId ? eq(issues.workspaceId, workspaceId) : void 0).orderBy(issues.order, desc(issues.createdAt), issues.id),
 			listNewestFirst: async () => await database.select().from(issues).orderBy(desc(issues.createdAt)),
 			listAll: async () => await database.select().from(issues),
 			listByWorkspace: async (workspaceId) => await database.select().from(issues).where(eq(issues.workspaceId, workspaceId)),
+			listPage: async (query) => await selectCardPage(database, query),
+			countByMilestone: async (workspaceId) => await database.select({
+				milestoneId: sql`${issues.milestoneId}`,
+				statusId: issues.statusId,
+				count: sql`cast(count(*) as int)`
+			}).from(issues).where(and(eq(issues.workspaceId, workspaceId), isNotNull(issues.milestoneId))).groupBy(issues.milestoneId, issues.statusId),
 			listByIds: async (issueIds) => await database.select().from(issues).where(inArray(issues.id, issueIds)),
 			findById: async (issueId) => {
 				const [row] = await database.select().from(issues).where(eq(issues.id, issueId)).limit(1);
@@ -481,6 +566,14 @@ function createStoreOver(database) {
 		},
 		comments: {
 			listByIssue: async (issueId) => (await database.select().from(issueComments).where(eq(issueComments.issueId, issueId)).orderBy(asc(issueComments.createdAt), asc(issueComments.seq))).map(toIssueComment),
+			listLatestByIssues: async (issueIds, authorKinds) => {
+				if (issueIds.length === 0 || authorKinds?.length === 0) return [];
+				const ranked = database.select({
+					id: issueComments.id,
+					commentRank: sql`cast(row_number() over (partition by ${issueComments.issueId} order by ${issueComments.createdAt} desc, ${issueComments.seq} desc) as int)`.as("comment_rank")
+				}).from(issueComments).where(and(inArray(issueComments.issueId, [...issueIds]), authorKinds === void 0 ? void 0 : inArray(issueComments.authorKind, [...authorKinds]))).as("ranked");
+				return (await database.select(getTableColumns(issueComments)).from(issueComments).innerJoin(ranked, eq(ranked.id, issueComments.id)).where(eq(ranked.commentRank, 1))).map(toIssueComment);
+			},
 			findById: async (commentId) => {
 				const [row] = await database.select().from(issueComments).where(eq(issueComments.id, commentId)).limit(1);
 				return row ? toIssueComment(row) : null;
@@ -916,5 +1009,3 @@ create trigger kanban_guard_approval_comment_updates
 `;
 //#endregion
 export { issueStatuses as _, BOARD_REFUSAL_ERRCODE as a, getBoardMigrationsPath as c, boardPostgresSchema as d, issueComments as f, issueRuns as g, issueRelations as h, BOARD_PERSON_ROLE as i, createPostgresBoardStore as l, issueMilestones as m, AGENT_WAITING_REFUSAL as n, BOARD_ROLE_SQL as o, issueFieldChanges as p, BOARD_AGENT_ROLE as r, assertBoardSchema as s, AGENT_APPROVAL_COMMENT_REFUSAL as t, BOARD_POSTGRES_TABLES as u, issues as v, kanbanMeta as y };
-
-//# sourceMappingURL=roles.sql-CvyCGt38.mjs.map