agent-dealer 1.1.5 → 1.1.6

package/bundle/server/dist/repository/issues.js

@@ -105,16 +105,72 @@ export function getIssue(id) {
 export function listIssues(status) {
     const db = getDb();
     if (!status) {
-        const rows = db.prepare("SELECT * FROM issues ORDER BY updated_at DESC").all();
+        const rows = db
+            .prepare("SELECT * FROM issues ORDER BY updated_at DESC, rowid DESC")
+            .all();
         return rows.map(rowToIssue);
     }
     const statuses = Array.isArray(status) ? status : [status];
     const placeholders = statuses.map(() => "?").join(",");
     const rows = db
-        .prepare(`SELECT * FROM issues WHERE status IN (${placeholders}) ORDER BY updated_at DESC`)
+        .prepare(`SELECT * FROM issues WHERE status IN (${placeholders}) ORDER BY updated_at DESC, rowid DESC`)
         .all(...statuses);
     return rows.map(rowToIssue);
 }
+/** NOT-228: page-size bounds for the Issues list (matches the report default/max). */
+export const ISSUES_LIST_DEFAULT_LIMIT = 25;
+export const ISSUES_LIST_MAX_LIMIT = 100;
+/** Escape the LIKE metacharacters in a user query so `%`/`_` match literally. */
+function escapeLikePattern(raw) {
+    return raw.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+/**
+ * NOT-228: server-side filtering + stable pagination for the Issues list.
+ * Ordering is `updated_at DESC, rowid DESC` so pages are repeatable when many
+ * rows share a timestamp; the filter applies before pagination so `total` and
+ * `totalPages` describe the full matching cohort.
+ */
+export function queryIssues(query = {}) {
+    const db = getDb();
+    const conditions = [];
+    const params = [];
+    const rawStatuses = query.status === undefined ? [] : Array.isArray(query.status) ? query.status : [query.status];
+    const statuses = rawStatuses.map((s) => String(s).trim()).filter(Boolean);
+    if (statuses.length > 0) {
+        conditions.push(`status IN (${statuses.map(() => "?").join(",")})`);
+        params.push(...statuses);
+    }
+    const search = query.search?.trim();
+    if (search) {
+        const pattern = `%${escapeLikePattern(search).toLowerCase()}%`;
+        conditions.push(`(LOWER(title) LIKE ? ESCAPE '\\' OR LOWER(COALESCE(external_label, '')) LIKE ? ESCAPE '\\')`);
+        params.push(pattern, pattern);
+    }
+    const repo = query.repo?.trim();
+    if (repo) {
+        conditions.push(`repo = ?`);
+        params.push(repo);
+    }
+    if (query.needsAttention) {
+        conditions.push(`EXISTS (SELECT 1 FROM human_actions ha WHERE ha.issue_id = issues.id AND ha.status = 'open')`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const rawLimit = query.limit === undefined ? ISSUES_LIST_DEFAULT_LIMIT : Math.floor(query.limit);
+    const limit = !Number.isFinite(rawLimit) || rawLimit < 1
+        ? ISSUES_LIST_DEFAULT_LIMIT
+        : Math.min(rawLimit, ISSUES_LIST_MAX_LIMIT);
+    const rawPage = query.page === undefined ? 1 : Math.floor(query.page);
+    const page = !Number.isFinite(rawPage) || rawPage < 1 ? 1 : rawPage;
+    const { total } = db
+        .prepare(`SELECT COUNT(*) AS total FROM issues ${where}`)
+        .get(...params);
+    const totalPages = total === 0 ? 0 : Math.ceil(total / limit);
+    const offset = (page - 1) * limit;
+    const rows = db
+        .prepare(`SELECT * FROM issues ${where} ORDER BY updated_at DESC, rowid DESC LIMIT ? OFFSET ?`)
+        .all(...params, limit, offset);
+    return { rows: rows.map(rowToIssue), page, limit, total, totalPages };
+}
 /**
  * Every issue ever imported for this external id, newest first. `(source, external_id)` is
  * deliberately non-unique (`idx_issues_external` is a plain index): one ticket may need a

package/bundle/server/dist/repository/issues.test.js

@@ -4,9 +4,10 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 process.env.AGENT_DEALER_HOME = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-issues-"));
-const { migrate } = await import("../db/index.js");
+const { migrate, getDb } = await import("../db/index.js");
 const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
-const { createIssue, getIssue, listIssues, transitionIssue, incrementIssueRound, findActiveIssueByExternalId, listIssuesByExternalId } = await import("./issues.js");
+const { createIssue, getIssue, listIssues, transitionIssue, incrementIssueRound, findActiveIssueByExternalId, listIssuesByExternalId, queryIssues, ISSUES_LIST_DEFAULT_LIMIT, ISSUES_LIST_MAX_LIMIT } = await import("./issues.js");
+const { createHumanAction, resolveHumanAction } = await import("./human-actions.js");
 before(() => {
     migrate();
 });
@@ -67,3 +68,93 @@ test("terminal-scoped lookup is per (source, externalId) pair", () => {
     assert.equal(findActiveIssueByExternalId("linear", "SHARED-1")?.id, linear.id);
     assert.equal(findActiveIssueByExternalId("manual", "SHARED-1"), null);
 });
+test("NOT-228: search matches title case-insensitively and ignores unrelated rows", () => {
+    const hit = createIssue(makeInput("NOT228 Quokka migration wobble"));
+    createIssue(makeInput("NOT228 unrelated zebra"));
+    const res = queryIssues({ search: "  WOBBLE " });
+    assert.ok(res.rows.some((i) => i.id === hit.id), "title match survives case/whitespace");
+    assert.ok(res.rows.every((i) => !i.title.includes("unrelated zebra")));
+    assert.equal(res.page, 1);
+    assert.equal(res.limit, ISSUES_LIST_DEFAULT_LIMIT);
+});
+test("NOT-228: search matches the external label case-insensitively", () => {
+    const labeled = createIssue({
+        ...makeInput("A plain title with no ticket in it"),
+        source: "linear",
+        externalId: "ext-228-label",
+        externalLabel: "NOT-175",
+    });
+    const res = queryIssues({ search: "not-175" });
+    assert.ok(res.rows.some((i) => i.id === labeled.id), "external label match");
+    assert.ok(res.rows.every((i) => i.id === labeled.id || (i.title + (i.externalLabel ?? "")).toLowerCase().includes("not-175")), "unrelated rows are excluded");
+});
+test("NOT-228: search treats LIKE metacharacters literally", () => {
+    const literal = createIssue(makeInput("NOT228 100% literal percent"));
+    createIssue(makeInput("NOT228 1000 literal thousand"));
+    const res = queryIssues({ search: "100%" });
+    assert.ok(res.rows.some((i) => i.id === literal.id));
+    assert.ok(res.rows.every((i) => (i.title + (i.externalLabel ?? "")).toLowerCase().includes("100%")));
+});
+test("NOT-228: status, repo, and search combine before pagination; totals describe the cohort", () => {
+    const repo = "github.com/not228/combo";
+    const a = createIssue({ ...makeInput("NOT228 combo alpha"), repo });
+    const b = createIssue({ ...makeInput("NOT228 combo beta"), repo });
+    createIssue({ ...makeInput("NOT228 combo other-repo"), repo: "github.com/not228/other" });
+    transitionIssue(b.id, "developing");
+    const res = queryIssues({ search: "combo", status: "ready", repo, limit: 1, page: 1 });
+    assert.equal(res.total, 1);
+    assert.equal(res.totalPages, 1);
+    assert.deepEqual(res.rows.map((i) => i.id), [a.id]);
+    const both = queryIssues({ search: "combo", repo });
+    assert.equal(both.total, 2, "status omitted: both statuses match");
+});
+test("NOT-228: equal updated_at rows paginate repeatably with rowid DESC as tiebreaker", () => {
+    const stamp = "2026-09-01T00:00:00.000Z";
+    const ids = ["NOT228 tie one", "NOT228 tie two", "NOT228 tie three"].map((t) => createIssue(makeInput(t)).id);
+    for (const id of ids) {
+        getDb().prepare("UPDATE issues SET updated_at = ? WHERE id = ?").run(stamp, id);
+    }
+    const first = queryIssues({ search: "NOT228 tie", limit: 2, page: 1 });
+    const second = queryIssues({ search: "NOT228 tie", limit: 2, page: 2 });
+    assert.equal(first.total, 3);
+    assert.equal(first.totalPages, 2);
+    // Newest rowid first: creation order was one, two, three.
+    assert.deepEqual(first.rows.map((i) => i.id), [ids[2], ids[1]]);
+    assert.deepEqual(second.rows.map((i) => i.id), [ids[0]]);
+    const again = queryIssues({ search: "NOT228 tie", limit: 2, page: 1 });
+    assert.deepEqual(again.rows.map((i) => i.id), first.rows.map((i) => i.id), "repeatable");
+});
+test("NOT-228: page/limit bounds clamp instead of erroring", () => {
+    const res = queryIssues({ search: "NOT228 tie", page: 0, limit: 0 });
+    assert.equal(res.page, 1);
+    assert.equal(res.limit, ISSUES_LIST_DEFAULT_LIMIT);
+    const capped = queryIssues({ search: "NOT228 tie", limit: 10_000 });
+    assert.equal(capped.limit, ISSUES_LIST_MAX_LIMIT);
+    const pastEnd = queryIssues({ search: "NOT228 tie", limit: 2, page: 99 });
+    assert.deepEqual(pastEnd.rows, []);
+    assert.equal(pastEnd.total, 3, "an out-of-range page keeps the cohort total");
+    assert.equal(pastEnd.page, 99);
+    const empty = queryIssues({ search: "NOT228 no-such-title-xyz" });
+    assert.deepEqual(empty.rows, []);
+    assert.equal(empty.total, 0);
+    assert.equal(empty.totalPages, 0);
+});
+test("NOT-228: needsAttention returns only issues with an open human action", () => {
+    const flagged = createIssue(makeInput("NOT228 flagged attention"));
+    const quiet = createIssue(makeInput("NOT228 quiet no-action"));
+    const action = createHumanAction({
+        issueId: flagged.id,
+        actionType: "final_review",
+        reason: "Reviewer approved",
+        question: "Accept?",
+        responseOptions: ["complete", "repair", "close"],
+    });
+    let res = queryIssues({ search: "NOT228 flagged attention", needsAttention: true });
+    assert.deepEqual(res.rows.map((i) => i.id), [flagged.id]);
+    res = queryIssues({ search: "NOT228 quiet no-action", needsAttention: true });
+    assert.deepEqual(res.rows, [], "issues without open actions are excluded");
+    resolveHumanAction(action.id, "tester", { choice: "complete" });
+    res = queryIssues({ search: "NOT228 flagged attention", needsAttention: true });
+    assert.deepEqual(res.rows, [], "resolved actions no longer flag the issue");
+    assert.ok(queryIssues({ search: "NOT228 quiet no-action" }).rows.some((i) => i.id === quiet.id));
+});

package/bundle/server/dist/routes/issues.js

@@ -2,7 +2,7 @@
 import fs from "node:fs";
 import { CreateIssueInput, UpdateIssueInput, } from "@agent-dealer/shared";
 import { getDb } from "../db/index.js";
-import { createIssue, getIssue, listIssues, findActiveIssueByExternalId, listIssuesByExternalId, updateIssue, listRecentRepos } from "../repository/issues.js";
+import { createIssue, getIssue, listIssues, findActiveIssueByExternalId, listIssuesByExternalId, queryIssues, updateIssue, listRecentRepos } from "../repository/issues.js";
 import { listWorkerSessionsForIssue, getActiveWorkerSessionForIssue } from "../repository/worker-sessions.js";
 import { getIssueArtifact, listArtifactsForIssue } from "../repository/artifacts-for-issue.js";
 import { listUsageEventsForIssue, summarizeIssueUsage } from "../repository/usage-events.js";
@@ -52,10 +52,8 @@ function readTraceTail(filePath, maxChars) {
 }
 export async function registerIssueRoutes(app) {
     app.get("/api/issues", async (req) => {
-        const status = req.query.status;
-        const issues = status ? listIssues(status.split(",")) : listIssues();
-        const openActionIssueIds = new Set(listOpenHumanActions().map((a) => a.issueId));
-        return issues.map((issue) => ({
+        const query = req.query;
+        const toRow = (openActionIssueIds) => (issue) => ({
             id: issue.id,
             title: issue.title,
             status: issue.status,
@@ -63,7 +61,35 @@ export async function registerIssueRoutes(app) {
             currentIntent: issue.currentIntent,
             updatedAt: issue.updatedAt,
             hasOpenHumanAction: openActionIssueIds.has(issue.id),
-        }));
+        });
+        // NOT-228: paginated web requests pass `page` and/or `limit` and get rows
+        // plus `{ page, limit, total, totalPages }`. Legacy callers (notably the
+        // CLI status query) omit both and keep the existing unpaginated array.
+        if (query.page !== undefined || query.limit !== undefined) {
+            const statuses = query.status
+                ? query.status.split(",").map((s) => s.trim()).filter(Boolean)
+                : undefined;
+            const result = queryIssues({
+                search: query.q,
+                status: statuses,
+                repo: query.repo,
+                needsAttention: query.needsAttention === "1" || query.needsAttention === "true",
+                page: query.page !== undefined ? Number(query.page) : undefined,
+                limit: query.limit !== undefined ? Number(query.limit) : undefined,
+            });
+            const openActionIssueIds = new Set(listOpenHumanActions().map((a) => a.issueId));
+            return {
+                issues: result.rows.map(toRow(openActionIssueIds)),
+                page: result.page,
+                limit: result.limit,
+                total: result.total,
+                totalPages: result.totalPages,
+            };
+        }
+        const status = query.status;
+        const issues = status ? listIssues(status.split(",")) : listIssues();
+        const openActionIssueIds = new Set(listOpenHumanActions().map((a) => a.issueId));
+        return issues.map(toRow(openActionIssueIds));
     });
     /** Recent portable GitHub repo identities (legacy local paths excluded from create UI). */
     app.get("/api/issues/recent-repos", async () => {

package/bundle/server/dist/routes/issues.test.js

@@ -16,6 +16,7 @@ const { migrate, getDb } = await import("../db/index.js");
 const { BUILTIN_AGENT_CLAUDE_ID, BUILTIN_AGENT_CURSOR_ID } = await import("@agent-dealer/shared");
 const { registerIssueRoutes } = await import("./issues.js");
 const { transitionIssue, listIssuesByExternalId, getIssue } = await import("../repository/issues.js");
+const { createHumanAction } = await import("../repository/human-actions.js");
 const { createIssueArtifact } = await import("../repository/artifacts.js");
 const { claimWorkItem } = await import("../repository/work-items.js");
 const { listHumanActionsForIssue } = await import("../repository/human-actions.js");
@@ -564,6 +565,41 @@ test("NOT-148: GET /api/issues/:id surfaces branchTipStatus with restart risk af
     assert.equal(idle.json().branchTipStatus, null);
     await app.close();
 });
+// NOT-228: helpers + focused tests for Issues list filtering/pagination. Every
+// test wipes `issues` in beforeEach, so the `R228` title marker scopes each
+// cohort without cross-test interference.
+const R228_PAYLOAD = {
+    repo: "acme/app",
+    baseBranch: "main",
+    developerAgentId: BUILTIN_AGENT_CLAUDE_ID,
+    reviewerAgentId: BUILTIN_AGENT_CURSOR_ID,
+};
+async function r228Seed(app, title, extra = {}) {
+    const res = await app.inject({
+        method: "POST",
+        url: "/api/issues",
+        payload: { ...R228_PAYLOAD, ...extra, title },
+    });
+    assert.equal(res.statusCode, 200);
+    return res.json();
+}
+async function r228Get(app, qs) {
+    const res = await app.inject({ method: "GET", url: `/api/issues${qs}` });
+    assert.equal(res.statusCode, 200);
+    return res.json();
+}
+test("NOT-228: omitting page/limit keeps the legacy unpaginated array (CLI contract)", async () => {
+    const app = await buildApp();
+    const created = await r228Seed(app, "R228 legacy contract");
+    for (const url of ["/api/issues", "/api/issues?status=ready", "/api/issues?q=R228&repo=github.com%2Facme%2Fapp"]) {
+        const res = await app.inject({ method: "GET", url });
+        assert.equal(res.statusCode, 200);
+        const body = res.json();
+        assert.ok(Array.isArray(body), `${url} still answers an array`);
+        assert.ok(body.some((i) => i.id === created.id));
+    }
+    await app.close();
+});
 test("NOT-217: PATCH agent assignments on a queued issue preserves position, refreshes the wait reason, and records issue.reassigned", async () => {
     const app = await buildApp();
     try {
@@ -623,6 +659,76 @@ test("NOT-217: PATCH agent assignments on a queued issue preserves position, ref
     }
     await app.close();
 });
+test("NOT-228: page/limit paginate with a default of 25 and totals for the full cohort", async () => {
+    const app = await buildApp();
+    for (let n = 0; n < 30; n++)
+        await r228Seed(app, `R228 pageable ${n}`);
+    const q = encodeURIComponent("R228 pageable");
+    const first = await r228Get(app, `?q=${q}&limit=25`);
+    assert.equal(first.issues.length, 25);
+    assert.equal(first.page, 1);
+    assert.equal(first.limit, 25);
+    assert.equal(first.total, 30);
+    assert.equal(first.totalPages, 2);
+    const second = await r228Get(app, `?q=${q}&limit=25&page=2`);
+    assert.equal(second.issues.length, 5);
+    assert.equal(second.total, 30);
+    assert.deepEqual(new Set([...first.issues, ...second.issues].map((i) => i.id)).size, 30, "pages neither duplicate nor skip rows");
+    // `page` alone still paginates (default limit); `limit` alone starts at page 1.
+    const defaulted = await r228Get(app, `?q=${q}&page=2`);
+    assert.equal(defaulted.limit, 25);
+    assert.equal(defaulted.issues.length, 5);
+    await app.close();
+});
+test("NOT-228: search, status, repo, and attention filters apply before pagination", async () => {
+    const app = await buildApp();
+    const repo = "github.com/r228/filtered";
+    const keep = await r228Seed(app, "R228 filter keep me", { repo });
+    const moved = await r228Seed(app, "R228 filter moved on", { repo });
+    await r228Seed(app, "R228 filter other repo", { repo: "github.com/r228/elsewhere" });
+    transitionIssue(moved.id, "developing");
+    createHumanAction({
+        issueId: moved.id,
+        actionType: "final_review",
+        reason: "Reviewer approved",
+        question: "Accept?",
+        responseOptions: ["complete"],
+    });
+    const q = encodeURIComponent("R228 filter");
+    const byStatus = await r228Get(app, `?q=${q}&status=developing&page=1&limit=10`);
+    assert.equal(byStatus.total, 1);
+    assert.deepEqual(byStatus.issues.map((i) => i.id), [moved.id]);
+    const byRepo = await r228Get(app, `?q=${q}&repo=${encodeURIComponent(repo)}&page=1&limit=10`);
+    assert.equal(byRepo.total, 2);
+    const attention = await r228Get(app, `?q=${q}&needsAttention=1&page=1&limit=10`);
+    assert.equal(attention.total, 1);
+    assert.deepEqual(attention.issues.map((i) => i.id), [moved.id]);
+    assert.equal(attention.issues[0].hasOpenHumanAction, true);
+    // Search matches the external label, not just the title: no "R228 filter"
+    // title contains "not-228", so only the labeled row matches.
+    const labeled = await r228Seed(app, "R228 filter label-only title", {
+        source: "linear",
+        externalId: "R228-LBL-1",
+        externalLabel: "NOT-228",
+    });
+    const byLabel = await r228Get(app, `?q=${encodeURIComponent("not-228")}&page=1&limit=10`);
+    assert.equal(byLabel.total, 1);
+    assert.deepEqual(byLabel.issues.map((i) => i.id), [labeled.id]);
+    void keep;
+    await app.close();
+});
+test("NOT-228: limit clamps to 100 and out-of-range pages keep totals", async () => {
+    const app = await buildApp();
+    await r228Seed(app, "R228 bounds one");
+    const capped = await r228Get(app, `?q=${encodeURIComponent("R228 bounds")}&page=1&limit=500`);
+    assert.equal(capped.limit, 100);
+    assert.equal(capped.total, 1);
+    const pastEnd = await r228Get(app, `?q=${encodeURIComponent("R228 bounds")}&page=9&limit=10`);
+    assert.deepEqual(pastEnd.issues, []);
+    assert.equal(pastEnd.total, 1);
+    assert.equal(pastEnd.page, 9);
+    await app.close();
+});
 test("NOT-217: PATCH reviewer-only edit records before/after reviewers without touching the developer", async () => {
     const app = await buildApp();
     const created = (await app.inject({

package/bundle/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-dealer/server",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -22,7 +22,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@agent-dealer/shared": "1.1.5",
+    "@agent-dealer/shared": "1.1.6",
     "@fastify/cors": "^11.0.1",
     "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",