@opencode-linear-agent/server 0.1.3-master.11 → 0.1.3-master.13

package/dist/index.js

@@ -66849,6 +66849,16 @@ function getOpencodeErrorMessage(error) {
   return JSON.stringify(error);
 }
 // ../core/src/linear/LinearServiceImpl.ts
+async function collectTeamLabels(team) {
+  const first = await team.labels();
+  const labels = [...first.nodes];
+  let page = first;
+  while (page.pageInfo.hasNextPage) {
+    page = await page.fetchNext();
+    labels.push(...page.nodes);
+  }
+  return labels;
+}
 async function collectIssueAgentSessionIds(fetchPage) {
   const ids = new Set;
   let after;
@@ -67102,6 +67112,92 @@ ${truncatedStack}
     }
     return result;
   }
+  async getIssueRepositorySuggestions(issueId, agentSessionId, candidates) {
+    const result = await Result.tryPromise({
+      try: async () => {
+        const response = await this.client.client.rawRequest(`query IssueRepositorySuggestions($issueId: String!, $agentSessionId: String!, $candidateRepositories: [RepositoryInput!]!) {
+            issueRepositorySuggestions(
+              issueId: $issueId
+              agentSessionId: $agentSessionId
+              candidateRepositories: $candidateRepositories
+            ) {
+              suggestions {
+                repositoryFullName
+                hostname
+                confidence
+              }
+            }
+          }`, {
+          issueId,
+          agentSessionId,
+          candidateRepositories: candidates
+        });
+        if (!response.data) {
+          return [];
+        }
+        return response.data.issueRepositorySuggestions.suggestions;
+      },
+      catch: mapLinearError
+    });
+    if (Result.isError(result)) {
+      this.log.error("Failed to get issue repository suggestions", {
+        issueId,
+        agentSessionId,
+        candidateCount: candidates.length,
+        error: result.error.message,
+        errorType: result.error._tag
+      });
+    }
+    return result;
+  }
+  async setIssueRepoLabel(issueId, labelName) {
+    const result = await Result.tryPromise({
+      try: async () => {
+        const issue = await this.client.issue(issueId);
+        const team = await issue.team;
+        if (!team) {
+          throw new Error("Issue has no associated team");
+        }
+        const issueLabels = await issue.labels();
+        const teamLabels = await collectTeamLabels(team);
+        let repoLabelId = teamLabels.find((label) => label.name.toLowerCase() === labelName.toLowerCase())?.id;
+        if (!repoLabelId) {
+          const response = await this.client.client.rawRequest(`mutation IssueLabelCreate($input: IssueLabelCreateInput!) {
+              issueLabelCreate(input: $input) {
+                success
+                issueLabel {
+                  id
+                }
+              }
+            }`, {
+            input: {
+              name: labelName,
+              teamId: team.id
+            }
+          });
+          repoLabelId = response.data?.issueLabelCreate.issueLabel?.id;
+          if (!repoLabelId) {
+            throw new Error(`Failed to create repo label ${labelName}`);
+          }
+        }
+        const labelIds = issueLabels.nodes.filter((label) => !label.name.startsWith("repo:")).map((label) => label.id);
+        await issue.update({
+          labelIds: [...labelIds, repoLabelId]
+        });
+      },
+      catch: mapLinearError
+    });
+    if (Result.isError(result)) {
+      this.log.error("Failed to set repo label on issue", {
+        issueId,
+        labelName,
+        error: result.error.message,
+        errorType: result.error._tag
+      });
+      return Result.err(result.error);
+    }
+    return Result.ok(undefined);
+  }
   async getIssueAgentSessionIds(issueId) {
     const result = await Result.tryPromise({
       try: async () => {
@@ -67181,29 +67277,44 @@ ${truncatedStack}
   }
 }
 // ../core/src/linear/label-parser.ts
-function parseRepoLabel(labels) {
+function findRepoLabel(labels) {
   const repoLabel = labels.find((label) => label.name.startsWith("repo:"));
   if (!repoLabel) {
-    return null;
+    return { status: "missing" };
   }
   const repoPath = repoLabel.name.slice(5);
   if (!repoPath.trim()) {
-    return null;
+    return { status: "invalid", label: repoLabel.name };
   }
   if (repoPath.includes("/")) {
     const [organizationName, repositoryName] = repoPath.split("/", 2);
     if (!organizationName?.trim() || !repositoryName?.trim()) {
-      return null;
+      return { status: "invalid", label: repoLabel.name };
     }
     return {
-      organizationName: organizationName.trim(),
-      repositoryName: repositoryName.trim()
+      status: "valid",
+      label: repoLabel.name,
+      value: {
+        organizationName: organizationName.trim(),
+        repositoryName: repositoryName.trim()
+      }
     };
   }
   return {
-    repositoryName: repoPath.trim()
+    status: "valid",
+    label: repoLabel.name,
+    value: {
+      repositoryName: repoPath.trim()
+    }
   };
 }
+function parseRepoLabel(labels) {
+  const result = findRepoLabel(labels);
+  if (result.status !== "valid") {
+    return null;
+  }
+  return result.value;
+}
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -81389,6 +81500,7 @@ class FileTokenStore {
 var SESSION_PREFIX = "session:";
 var QUESTION_PREFIX = "question:";
 var PERMISSION_PREFIX = "permission:";
+var REPO_SELECTION_PREFIX = "repo-selection:";
 
 class FileSessionRepository {
   kv;
@@ -81422,26 +81534,377 @@ class FileSessionRepository {
   async deletePendingPermission(linearSessionId) {
     await this.kv.delete(`${PERMISSION_PREFIX}${linearSessionId}`);
   }
+  async getPendingRepoSelection(linearSessionId) {
+    return this.kv.get(`${REPO_SELECTION_PREFIX}${linearSessionId}`);
+  }
+  async savePendingRepoSelection(selection) {
+    await this.kv.put(`${REPO_SELECTION_PREFIX}${selection.linearSessionId}`, selection);
+  }
+  async deletePendingRepoSelection(linearSessionId) {
+    await this.kv.delete(`${REPO_SELECTION_PREFIX}${linearSessionId}`);
+  }
 }
 // src/RepoResolver.ts
 import { join as join3 } from "path";
-async function resolveRepoPath(linear2, issueId, projectsPath) {
+import { readdir } from "fs/promises";
+function toRepoLabelSuggestion(candidate, confidence) {
+  const parts = candidate.repositoryFullName.split("/");
+  const repositoryName = parts[parts.length - 1] ?? candidate.repositoryFullName;
+  return {
+    confidence,
+    hostname: candidate.hostname,
+    labelValue: `repo:${candidate.repositoryFullName}`,
+    repositoryFullName: candidate.repositoryFullName,
+    repositoryName
+  };
+}
+async function getCandidateRepositories(projectsPath) {
+  const result = await Result.tryPromise({
+    try: async () => readdir(projectsPath, { withFileTypes: true }),
+    catch: (e) => e instanceof Error ? e.message : String(e)
+  });
+  if (Result.isError(result)) {
+    return [];
+  }
+  return result.value.filter((entry) => entry.isDirectory()).map((entry) => ({
+    hostname: "github.com",
+    repositoryFullName: entry.name
+  }));
+}
+async function resolveRepoPath(linear2, issueId, agentSessionId, projectsPath) {
   const log = Log.create({ service: "repo-resolver" }).tag("issueId", issueId);
   const labelsResult = await linear2.getIssueLabels(issueId);
   if (Result.isError(labelsResult)) {
     return Result.err(labelsResult.error);
   }
-  const repoLabel = parseRepoLabel(labelsResult.value);
-  if (!repoLabel) {
-    log.info("No repo label, using projectsPath root", { projectsPath });
-    return Result.ok({ path: projectsPath, repoName: null });
+  const parsedRepoLabel = parseRepoLabel(labelsResult.value);
+  const repoLabel = findRepoLabel(labelsResult.value);
+  if (parsedRepoLabel) {
+    const repoPath = join3(projectsPath, parsedRepoLabel.repositoryName);
+    log.info("Resolved repo from label", {
+      repoName: parsedRepoLabel.repositoryName,
+      repoPath
+    });
+    return Result.ok({
+      status: "resolved",
+      path: repoPath,
+      repoName: parsedRepoLabel.repositoryName
+    });
+  }
+  const candidates = await getCandidateRepositories(projectsPath);
+  const suggestionsResult = candidates.length ? await linear2.getIssueRepositorySuggestions(issueId, agentSessionId, candidates) : Result.ok([]);
+  const suggestions = Result.isOk(suggestionsResult) ? suggestionsResult.value.toSorted((a, b) => b.confidence - a.confidence).slice(0, 3).map((candidate) => toRepoLabelSuggestion(candidate, candidate.confidence)) : candidates.slice(0, 3).map((candidate) => toRepoLabelSuggestion(candidate, null));
+  log.info("Repo label required before session start", {
+    reason: repoLabel.status,
+    invalidLabel: repoLabel.status === "invalid" ? repoLabel.label : undefined,
+    suggestionCount: suggestions.length
+  });
+  const reason = repoLabel.status === "invalid" ? "invalid" : "missing";
+  return Result.ok({
+    status: "needs_repo_label",
+    reason,
+    invalidLabel: repoLabel.status === "invalid" ? repoLabel.label : undefined,
+    exampleLabel: suggestions[0]?.labelValue ?? "repo:opencode-linear-agent",
+    suggestions
+  });
+}
+
+// src/AgentSessionDispatcher.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function readStringField2(value, field) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const candidate = value[field];
+  if (typeof candidate !== "string") {
+    return null;
+  }
+  const trimmed = candidate.trim();
+  return trimmed.length > 0 ? candidate : null;
+}
+function readPromptContextText2(promptContext) {
+  if (typeof promptContext === "string") {
+    const trimmed = promptContext.trim();
+    return trimmed.length > 0 ? promptContext : null;
+  }
+  const body = readStringField2(promptContext, "body");
+  if (body) {
+    return body;
+  }
+  if (isRecord2(promptContext)) {
+    const contentBody = readStringField2(promptContext.content, "body");
+    if (contentBody) {
+      return contentBody;
+    }
+  }
+  return null;
+}
+function extractPromptedUserResponse2(event) {
+  const agentBody = readStringField2(event.agentActivity, "body");
+  if (agentBody) {
+    return agentBody;
+  }
+  if (isRecord2(event.agentActivity)) {
+    const contentBody = readStringField2(event.agentActivity.content, "body");
+    if (contentBody) {
+      return contentBody;
+    }
+  }
+  const promptContextBody = readPromptContextText2(event.promptContext);
+  if (promptContextBody) {
+    return promptContextBody;
   }
-  const repoPath = join3(projectsPath, repoLabel.repositoryName);
-  log.info("Resolved repo from label", {
-    repoName: repoLabel.repositoryName,
-    repoPath
+  return "";
+}
+function normalizeMatchInput2(value) {
+  return value.trim().toLowerCase();
+}
+function hasWordBoundaryMatch2(haystack, needle) {
+  const regex = new RegExp(`\\b${escapeRegex3(needle)}\\b`, "i");
+  return regex.test(haystack);
+}
+function escapeRegex3(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchRepoSelectionOption(userResponse, options) {
+  const normalizedResponse = normalizeMatchInput2(userResponse);
+  if (normalizedResponse.length === 0) {
+    return null;
+  }
+  for (const opt of options) {
+    if (normalizeMatchInput2(opt.labelValue) === normalizedResponse) {
+      return opt.labelValue;
+    }
+  }
+  for (const opt of options) {
+    for (const alias of opt.aliases) {
+      if (normalizeMatchInput2(alias) === normalizedResponse) {
+        return opt.labelValue;
+      }
+    }
+  }
+  for (const opt of options) {
+    if (normalizedResponse.startsWith(normalizeMatchInput2(opt.labelValue))) {
+      return opt.labelValue;
+    }
+  }
+  for (const opt of options) {
+    for (const alias of opt.aliases) {
+      const normalizedAlias = normalizeMatchInput2(alias);
+      if (normalizedResponse.startsWith(normalizedAlias)) {
+        return opt.labelValue;
+      }
+    }
+  }
+  for (const opt of options) {
+    if (hasWordBoundaryMatch2(userResponse, normalizeMatchInput2(opt.labelValue))) {
+      return opt.labelValue;
+    }
+  }
+  for (const opt of options) {
+    for (const alias of opt.aliases) {
+      const normalizedAlias = normalizeMatchInput2(alias);
+      if (hasWordBoundaryMatch2(userResponse, normalizedAlias)) {
+        return opt.labelValue;
+      }
+    }
+  }
+  return null;
+}
+function matchExactRepoSelectionOption(userResponse, options) {
+  const normalizedResponse = normalizeMatchInput2(userResponse);
+  if (normalizedResponse.length === 0) {
+    return null;
+  }
+  for (const opt of options) {
+    if (normalizeMatchInput2(opt.labelValue) === normalizedResponse) {
+      return opt.labelValue;
+    }
+  }
+  for (const opt of options) {
+    for (const alias of opt.aliases) {
+      if (normalizeMatchInput2(alias) === normalizedResponse) {
+        return opt.labelValue;
+      }
+    }
+  }
+  return null;
+}
+function buildRepoSelectionOptions(resolution) {
+  return resolution.suggestions.map((suggestion) => {
+    const aliases = [
+      suggestion.labelValue,
+      suggestion.repositoryFullName,
+      suggestion.repositoryName
+    ];
+    return {
+      label: suggestion.repositoryFullName,
+      labelValue: suggestion.labelValue,
+      aliases
+    };
   });
-  return Result.ok({ path: repoPath, repoName: repoLabel.repositoryName });
+}
+function buildRepoLabelErrorBody(resolution) {
+  const lines = [
+    resolution.reason === "invalid" ? `Missing valid repository label. Replace \`${resolution.invalidLabel ?? "repo:"}\` with a valid \`repo:*\` label before re-running.` : "Missing repository label. Add a `repo:*` label before re-running.",
+    "",
+    `Example: \`${resolution.exampleLabel}\``
+  ];
+  if (resolution.suggestions.length > 0) {
+    lines.push("", "Suggested labels:", ...resolution.suggestions.map((suggestion) => suggestion.confidence === null ? `- \`${suggestion.labelValue}\`` : `- \`${suggestion.labelValue}\` (${Math.round(suggestion.confidence * 100)}%)`));
+  }
+  lines.push("", "I stopped before creating any OpenCode session or worktree.");
+  return lines.join(`
+`);
+}
+function buildRepoSelectionBody(resolution, invalidResponse) {
+  const lines = [
+    resolution.reason === "invalid" ? `Replace invalid label \`${resolution.invalidLabel ?? "repo:"}\` by picking a repository or replying with a label like \`${resolution.exampleLabel}\`.` : `Pick a repository or reply with a label like \`${resolution.exampleLabel}\`.`
+  ];
+  if (invalidResponse) {
+    lines.push("", `I couldn't use \`${invalidResponse}\`. Reply with \`repo:name\`, \`name\`, or pick one below.`);
+  }
+  return lines.join(`
+`);
+}
+function normalizeRepoLabelInput(userResponse) {
+  const trimmed = userResponse.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const label = trimmed.startsWith("repo:") ? trimmed : `repo:${trimmed}`;
+  const parsed = parseRepoLabel([{ name: label }]);
+  if (!parsed) {
+    return null;
+  }
+  if (parsed.organizationName) {
+    return `repo:${parsed.organizationName}/${parsed.repositoryName}`;
+  }
+  return `repo:${parsed.repositoryName}`;
+}
+function toStartupEvent(event, promptContext) {
+  return {
+    ...event,
+    action: "created",
+    promptContext: promptContext ?? event.promptContext
+  };
+}
+async function processWithRepo(event, repoPath, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo) {
+  if (processWithResolvedRepo) {
+    await processWithResolvedRepo(event, repoPath);
+    return;
+  }
+  const processor = new LinearEventProcessor(opencode2, linear2, sessionRepository, repoPath, {
+    organizationId: config2.organizationId
+  });
+  await processor.process(event);
+}
+async function reportMissingRepoLabel(linear2, linearSessionId, resolution) {
+  await linear2.postError(linearSessionId, new Error(buildRepoLabelErrorBody(resolution)));
+}
+async function promptForRepoSelection(linear2, sessionRepository, linearSessionId, issueId, resolution, promptContext, invalidResponse) {
+  const options = buildRepoSelectionOptions(resolution);
+  const pendingSelection = {
+    linearSessionId,
+    issueId,
+    options,
+    promptContext,
+    createdAt: Date.now()
+  };
+  await sessionRepository.savePendingRepoSelection(pendingSelection);
+  await linear2.postElicitation(linearSessionId, buildRepoSelectionBody(resolution, invalidResponse), "select", {
+    options: options.map((option) => ({
+      label: option.label,
+      value: option.labelValue
+    }))
+  });
+}
+async function handleRepoSelectionPrompt(event, pendingSelection, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo) {
+  const linearSessionId = event.agentSession.id;
+  const issueId = event.agentSession.issue?.id ?? event.agentSession.issueId;
+  const issueIdentifier = event.agentSession.issue?.identifier ?? issueId ?? "unknown";
+  const log = Log.create({ service: "dispatcher" }).tag("organizationId", config2.organizationId).tag("issue", issueIdentifier);
+  const userResponse = extractPromptedUserResponse2(event);
+  const selectedLabel = matchExactRepoSelectionOption(userResponse, pendingSelection.options) ?? normalizeRepoLabelInput(userResponse) ?? matchRepoSelectionOption(userResponse, pendingSelection.options);
+  if (!selectedLabel) {
+    await promptForRepoSelection(linear2, sessionRepository, linearSessionId, pendingSelection.issueId, {
+      status: "needs_repo_label",
+      reason: "missing",
+      exampleLabel: pendingSelection.options[0]?.labelValue ?? "repo:opencode-linear-agent",
+      suggestions: pendingSelection.options.map((option) => ({
+        confidence: null,
+        hostname: "github.com",
+        labelValue: option.labelValue,
+        repositoryFullName: option.label,
+        repositoryName: option.label.replace(/^.*\//, "")
+      }))
+    }, pendingSelection.promptContext, userResponse);
+    return;
+  }
+  const setLabelResult = await linear2.setIssueRepoLabel(pendingSelection.issueId, selectedLabel);
+  if (Result.isError(setLabelResult)) {
+    log.error("Failed to set selected repo label", {
+      labelValue: selectedLabel,
+      error: setLabelResult.error.message,
+      errorType: setLabelResult.error._tag
+    });
+    await linear2.postError(linearSessionId, setLabelResult.error);
+    return;
+  }
+  await sessionRepository.deletePendingRepoSelection(linearSessionId);
+  const parsed = findRepoLabel([{ name: selectedLabel }]);
+  if (parsed.status !== "valid") {
+    await linear2.postError(linearSessionId, new Error(`Invalid repo label selected: ${selectedLabel}`));
+    return;
+  }
+  await processWithRepo(toStartupEvent(event, pendingSelection.promptContext), `${config2.projectsPath}/${parsed.value.repositoryName}`, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo);
+}
+async function dispatchAgentSessionEvent(event, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo) {
+  const linearSessionId = event.agentSession.id;
+  const issueId = event.agentSession.issue?.id ?? event.agentSession.issueId;
+  const issueIdentifier = event.agentSession.issue?.identifier ?? issueId ?? "unknown";
+  const log = Log.create({ service: "dispatcher" }).tag("organizationId", config2.organizationId).tag("issue", issueIdentifier);
+  const pendingSelection = await sessionRepository.getPendingRepoSelection(linearSessionId);
+  if (pendingSelection) {
+    await handleRepoSelectionPrompt(event, pendingSelection, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo);
+    return;
+  }
+  const sessionState = await sessionRepository.get(linearSessionId);
+  if (event.action === "prompted" && sessionState?.repoDirectory) {
+    log.info("Using existing session repo directory", {
+      repoPath: sessionState.repoDirectory
+    });
+    await processWithRepo(event, sessionState.repoDirectory, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo);
+    return;
+  }
+  if (!issueId) {
+    await linear2.postError(linearSessionId, new Error("Missing issue id"));
+    return;
+  }
+  const resolveResult = await resolveRepoPath(linear2, issueId, linearSessionId, config2.projectsPath);
+  if (Result.isError(resolveResult)) {
+    log.error("Failed to resolve repository", {
+      error: resolveResult.error.message
+    });
+    await linear2.postError(linearSessionId, resolveResult.error);
+    return;
+  }
+  const resolved = resolveResult.value;
+  if (resolved.status === "needs_repo_label") {
+    if (resolved.suggestions.length > 0) {
+      await promptForRepoSelection(linear2, sessionRepository, linearSessionId, issueId, resolved, readPromptContextText2(event.promptContext) ?? undefined);
+      return;
+    }
+    await reportMissingRepoLabel(linear2, linearSessionId, resolved);
+    return;
+  }
+  log.info("Using repository path", {
+    repoPath: resolved.path,
+    repoName: resolved.repoName
+  });
+  await processWithRepo(sessionState ? event : toStartupEvent(event), resolved.path, linear2, opencode2, sessionRepository, config2, processWithResolvedRepo);
 }
 
 // src/index.ts
@@ -81487,13 +81950,9 @@ function createDirectDispatcher(config2, tokenStore, sessionRepository) {
         await issueHandler.process(event);
         return;
       }
-      const linearSessionId = event.agentSession.id;
-      const issueId = event.agentSession.issue?.id ?? event.agentSession.issueId ?? "unknown";
-      const issueIdentifier = event.agentSession.issue?.identifier ?? issueId;
-      const log = Log.create({ service: "dispatcher" }).tag("organizationId", organizationId).tag("issue", issueIdentifier);
       let accessToken = await tokenStore.getAccessToken(organizationId);
       if (!accessToken) {
-        log.info("No access token, attempting refresh");
+        Log.create({ service: "dispatcher" }).tag("organizationId", organizationId).info("No access token, attempting refresh");
         const oauthConfig = {
           clientId: config2.linear.clientId,
           clientSecret: config2.linear.clientSecret
@@ -81501,23 +81960,10 @@ function createDirectDispatcher(config2, tokenStore, sessionRepository) {
         accessToken = await refreshAccessToken(oauthConfig, tokenStore, organizationId);
       }
       const linear2 = new LinearServiceImpl(accessToken);
-      const resolveResult = await resolveRepoPath(linear2, issueId, config2.projectsPath);
-      if (Result.isError(resolveResult)) {
-        log.error("Failed to resolve repository", {
-          error: resolveResult.error.message
-        });
-        await linear2.postError(linearSessionId, resolveResult.error);
-        return;
-      }
-      const resolved = resolveResult.value;
-      log.info("Using repository path", {
-        repoPath: resolved.path,
-        repoName: resolved.repoName
+      await dispatchAgentSessionEvent(event, linear2, opencode2, sessionRepository, {
+        organizationId,
+        projectsPath: config2.projectsPath
       });
-      const processor = new LinearEventProcessor(opencode2, linear2, sessionRepository, resolved.path, {
-        organizationId
-      });
-      await processor.process(event);
     }
   };
 }
@@ -81651,11 +82097,13 @@ Make sure OpenCode is running: opencode serve
 `);
   return server2;
 }
-main().catch((error48) => {
-  const log = Log.create({ service: "startup" });
-  log.error("Failed to start server", {
-    error: error48 instanceof Error ? error48.message : String(error48),
-    stack: error48 instanceof Error ? error48.stack : undefined
+if (import.meta.main) {
+  main().catch((error48) => {
+    const log = Log.create({ service: "startup" });
+    log.error("Failed to start server", {
+      error: error48 instanceof Error ? error48.message : String(error48),
+      stack: error48 instanceof Error ? error48.stack : undefined
+    });
+    process.exit(1);
   });
-  process.exit(1);
-});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-linear-agent/server",
-  "version": "0.1.3-master.11",
+  "version": "0.1.3-master.13",
   "type": "module",
   "main": "dist/index.js",
   "bin": {