agent-dealer 1.2.12 → 1.2.14

package/bundle/server/dist/adapters/git-worktree.js

@@ -1042,6 +1042,21 @@ export async function resolveDeveloperWorktree(opts) {
             ref = `origin/${opts.branchName}`;
             newBranch = opts.branchName;
         }
+        else if (reuseRemoteSha === null && !(await branchExists(opts.repo, opts.branchName))) {
+            // NOT-362: the reuse path was taken for a branch that exists nowhere — a
+            // freshly seeded Linear `branchName` (or `issue-<id>` fallback) has no
+            // local ref and the remote never saw it (`git worktree add <path>
+            // <branch>` would reject the unknown ref). Cut it fresh from the base
+            // instead of checking out a branch that does not exist.
+            const fresh = await fetchFreshBase(opts.repo, opts.baseBranch, opts.fetchTimeoutMs);
+            if (!fresh.ok) {
+                return { kind: "base_unavailable", reason: fresh.reason };
+            }
+            ref = fresh.ref;
+            newBranch = opts.branchName;
+            baseSha = fresh.sha;
+            baseRef = fresh.ref;
+        }
         else {
             // NOT-219: when the remote tip is known and the local ref is strictly behind
             // it (an ancestor of it), advance the local ref to the pushed tip before

package/bundle/server/dist/adapters/git-worktree.test.js

@@ -1183,6 +1183,36 @@ test("NOT-197: a fresh developer branch starts from the fetched origin/<base>, n
         fs.rmSync(isoRemote, { recursive: true, force: true });
     }
 });
+test("NOT-362: a seeded Linear branch name that exists nowhere starts round 1 from a fresh base cut", async () => {
+    // Round-1 shape after intake seeding: developer-effect computes
+    // reuseBranch = true from the seeded issue.branch, but the branch has no
+    // local ref and the remote never saw it. Pre-fix this reached
+    // `git worktree add <path> <branch>` with no newBranch and git rejected the
+    // unknown ref; now it cuts the seeded name fresh from the fetched base.
+    const { isoRepo, isoRemote } = makeIsoRepoPair("362seed");
+    const branch = "yusukemuraoka/ate-4-some-work";
+    try {
+        assert.equal(await branchExists(isoRepo, branch), false);
+        const resolved = await resolveDeveloperWorktree({
+            repo: isoRepo,
+            sessionId: "s-362-seed",
+            branchName: branch,
+            baseBranch: "main",
+            reuseBranch: true,
+        });
+        assert.equal(resolved.kind, "created");
+        if (resolved.kind !== "created")
+            return;
+        const originTip = git(isoRepo, "rev-parse", "origin/main");
+        assert.equal(git(resolved.path, "rev-parse", "HEAD"), originTip);
+        assert.equal(git(isoRepo, "rev-parse", branch), originTip);
+        await removeIsoWorktree(isoRepo, resolved.path, branch);
+    }
+    finally {
+        fs.rmSync(isoRepo, { recursive: true, force: true });
+        fs.rmSync(isoRemote, { recursive: true, force: true });
+    }
+});
 test("NOT-197: a failed pre-branch fetch returns base_unavailable and creates no branch", async () => {
     const { isoRepo, isoRemote } = makeIsoRepoPair("fail");
     try {

package/bundle/server/dist/adapters/linear-inbox.js

@@ -1,9 +1,13 @@
 import { resolveLinearRepoWithMappings } from "@agent-dealer/shared";
+import { getDb } from "../db/index.js";
+import { getIssue, listIssuesByExternalId } from "../repository/issues.js";
 import { DEFAULT_LINEAR_STATE_FILTER, getLinearIntakeConfig } from "../repository/intake-settings.js";
 import { listRepositoryMappings } from "../repository/repository-mappings.js";
-import { linearGraphqlRequest } from "./linear-graphql.js";
+import { LinearApiKeyMissingError, linearGraphqlRequest } from "./linear-graphql.js";
 export { DEFAULT_LINEAR_STATE_FILTER };
-const PAGE_SIZE = 50;
+/** NOT-361: first-page bound for the From Linear picker — never walk further cursors. */
+export const LINEAR_CANDIDATE_PAGE_SIZE = 50;
+const PAGE_SIZE = LINEAR_CANDIDATE_PAGE_SIZE;
 function hasApiKey() {
     return Boolean(process.env.LINEAR_API_KEY);
 }
@@ -21,8 +25,45 @@ async function linearQuery(operation, query, variables, opts) {
  * deterministic (one valid label resolves, zero is unresolved, several
  * conflict, a bad value is invalid) and never guesses from anything else.
  */
+/**
+ * NOT-364: the issue's own `attachments` connection — file uploads and
+ * external links attached to the ticket itself. Comment bodies and files
+ * uploaded only inside comments are never queried and never snapshotted.
+ * `source` is Linear's own metadata scalar; non-string values are coerced to
+ * a short string so the contract stays stable regardless of shape.
+ */
+export function nodeToAttachment(a) {
+    if (!a || typeof a.id !== "string" || !a.id)
+        return null;
+    if (typeof a.url !== "string" || !a.url)
+        return null;
+    const out = {
+        id: a.id,
+        title: typeof a.title === "string" && a.title ? a.title : a.id,
+        url: a.url,
+    };
+    if (typeof a.subtitle === "string" && a.subtitle)
+        out.subtitle = a.subtitle;
+    if (typeof a.source === "string" && a.source) {
+        out.source = a.source;
+    }
+    else if (a.source != null && typeof a.source === "object") {
+        try {
+            const rendered = JSON.stringify(a.source);
+            if (rendered && rendered !== "{}")
+                out.source = rendered;
+        }
+        catch {
+            // ignore unserializable source metadata
+        }
+    }
+    return out;
+}
 export function nodeToCandidate(n, mappings) {
     const labels = n.labels?.nodes.map((l) => l.name) ?? [];
+    const attachments = (n.attachments?.nodes ?? [])
+        .map(nodeToAttachment)
+        .filter((a) => a !== null);
     return {
         id: n.id,
         identifier: n.identifier,
@@ -31,8 +72,15 @@ export function nodeToCandidate(n, mappings) {
         url: n.url,
         state: n.state?.name,
         teamId: n.team?.id,
+        // NOT-362: Linear's suggested branch name, when it returns one.
+        ...(typeof n.branchName === "string" && n.branchName.trim()
+            ? { branchName: n.branchName }
+            : {}),
         labels,
         repoResolution: resolveLinearRepoWithMappings(labels, mappings ?? []),
+        // Always present (possibly empty) so the UI can distinguish "no
+        // attachments" from "queried before attachments existed".
+        attachments,
     };
 }
 const ISSUE_FIELDS = `
@@ -41,9 +89,11 @@ const ISSUE_FIELDS = `
   title
   description
   url
+  branchName
   state { name }
   team { id }
   labels { nodes { name } }
+  attachments { nodes { id title url subtitle source } }
 `;
 export async function getLinearViewer() {
     if (!hasApiKey())
@@ -81,35 +131,89 @@ export function parseLinearIssueRef(raw) {
     }
     return null;
 }
+/**
+ * NOT-361: at most one GraphQL page of candidates, most recently updated first.
+ * Does not walk `pageInfo` cursors — `hasMore` tells the UI when matches remain.
+ */
 export async function listLinearCandidates() {
     if (!hasApiKey())
-        return [];
+        return { candidates: [], hasMore: false };
     const settings = getLinearIntakeConfig();
     let viewerId;
     if (settings.assigneeMe) {
         const viewer = await getLinearViewer();
         viewerId = viewer?.id;
         if (!viewerId)
-            return [];
+            return { candidates: [], hasMore: false };
     }
     const filter = buildIssueFilter(settings, viewerId);
-    const nodes = [];
-    let after;
+    const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter) {
+      issues(filter: $filter, first: ${PAGE_SIZE}, orderBy: updatedAt) {
+        nodes { ${ISSUE_FIELDS} }
+        pageInfo { hasNextPage }
+      }
+    }`, { filter }));
+    // NOT-260: mappings load once per list operation, not once per candidate.
+    const mappings = listRepositoryMappings();
+    return {
+        candidates: data.issues.nodes.map((n) => nodeToCandidate(n, mappings)),
+        hasMore: Boolean(data.issues.pageInfo.hasNextPage),
+    };
+}
+/** Page size when walking Linear teams for the filter editor metadata. */
+const METADATA_TEAM_PAGE_SIZE = 50;
+/**
+ * NOT-361: teams, workflow statuses, and the authenticated Linear viewer for
+ * the inline filter editor — never ask the operator for raw UUIDs or CSV text.
+ * Teams are walked page-by-page so large workspaces are not truncated at
+ * Linear's default first page.
+ */
+export async function fetchLinearIntakeMetadata() {
+    if (!hasApiKey())
+        throw new LinearApiKeyMissingError();
+    const viewerData = (await linearQuery("fetchLinearIntakeMetadataViewer", `query IntakeMetadataViewer { viewer { id name email } }`));
+    const teams = [];
+    const workflowStates = [];
+    let after = null;
     for (;;) {
-        const data = (await linearQuery("listLinearCandidates", `query PollIssues($filter: IssueFilter, $after: String) {
-        issues(filter: $filter, first: ${PAGE_SIZE}, after: $after) {
-          nodes { ${ISSUE_FIELDS} }
+        const page = (await linearQuery("fetchLinearIntakeMetadataTeams", `query IntakeMetadataTeams($first: Int!, $after: String) {
+        teams(first: $first, after: $after) {
+          nodes {
+            id
+            name
+            key
+            states { nodes { name type } }
+          }
           pageInfo { hasNextPage endCursor }
         }
-      }`, { filter, after: after ?? null }));
-        nodes.push(...data.issues.nodes);
-        if (!data.issues.pageInfo.hasNextPage || !data.issues.pageInfo.endCursor)
+      }`, { first: METADATA_TEAM_PAGE_SIZE, after }));
+        for (const team of page.teams?.nodes ?? []) {
+            teams.push({ id: team.id, name: team.name, key: team.key });
+            for (const state of team.states?.nodes ?? []) {
+                const name = state.name?.trim();
+                if (!name)
+                    continue;
+                workflowStates.push({ name, type: state.type, teamId: team.id });
+            }
+        }
+        if (!page.teams?.pageInfo?.hasNextPage || !page.teams.pageInfo.endCursor)
             break;
-        after = data.issues.pageInfo.endCursor;
+        after = page.teams.pageInfo.endCursor;
     }
-    // NOT-260: mappings load once per list operation, not once per candidate.
-    const mappings = listRepositoryMappings();
-    return nodes.map((n) => nodeToCandidate(n, mappings));
+    // Stable team order by name; statuses keep Linear's per-team order, then
+    // unique-by-name order is left to the UI when "All teams" is selected.
+    teams.sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        teams,
+        workflowStates,
+        viewer: viewerData.viewer
+            ? {
+                id: viewerData.viewer.id,
+                name: viewerData.viewer.name,
+                email: viewerData.viewer.email,
+            }
+            : null,
+    };
 }
 export async function getLinearIssue(issueId) {
     const data = (await linearQuery("getLinearIssue", `query Issue($id: String!) {
@@ -283,3 +387,52 @@ export async function lookupLinearIssue(raw) {
         return null;
     return getLinearIssue(id);
 }
+/**
+ * NOT-362: seed a freshly imported Linear issue's branch from Linear's own
+ * `branchName`, so published branches carry the Linear identifier on
+ * repositories Linear's GitHub integration covers.
+ *
+ * Runs once at intake (POST /api/issues, source `linear`): a branch the
+ * workflow already wrote (clean_handoff ground truth) is never overwritten,
+ * manual (`source != 'linear'`) issues are untouched, and a Linear issue with
+ * no branch name falls back to the conventional `issue-<id>` — the same value
+ * `developerBranchName` would derive, materialized so the stored row says it.
+ * First pass only: a second Dealer issue for the same ticket (NOT-141) keeps
+ * `issue-<id>` so it never reuses the first pass's branch.
+ * Best-effort: an unreadable Linear (no key, outage) leaves the branch null
+ * and never fails the import.
+ */
+export async function persistLinearBranchForIssue(issueId) {
+    try {
+        const issue = getIssue(issueId);
+        if (!issue || issue.source !== "linear" || !issue.externalId)
+            return issue?.branch ?? null;
+        if (issue.branch)
+            return issue.branch;
+        // NOT-362 round 3: Linear's branchName is per Linear ticket, but each Dealer
+        // issue needs a unique branch per pass. routes/issues.ts (NOT-141) creates a
+        // fresh Dealer issue when an earlier pass for the same ticket is done/closed,
+        // and auto-merge squashes without deleting the branch — so a second pass
+        // seeded with the same Linear name would check out the first pass's branch
+        // (still holding pre-squash commits) and `gh pr view <branch>` could return
+        // the old MERGED PR. Seed the Linear name only for the first pass; later
+        // passes keep the conventional `issue-<id>`.
+        const priorPass = listIssuesByExternalId(issue.source, issue.externalId).some((row) => row.id !== issue.id);
+        if (priorPass) {
+            const fallback = `issue-${issue.id}`;
+            getDb()
+                .prepare("UPDATE issues SET branch = ?, updated_at = ? WHERE id = ? AND branch IS NULL")
+                .run(fallback, new Date().toISOString(), issue.id);
+            return getIssue(issue.id)?.branch ?? fallback;
+        }
+        const candidate = await getLinearIssue(issue.externalId);
+        const branch = candidate?.branchName?.trim() || `issue-${issue.id}`;
+        getDb()
+            .prepare("UPDATE issues SET branch = ?, updated_at = ? WHERE id = ? AND branch IS NULL")
+            .run(branch, new Date().toISOString(), issue.id);
+        return getIssue(issue.id)?.branch ?? branch;
+    }
+    catch {
+        return getIssue(issueId)?.branch ?? null;
+    }
+}