@danypops/tickets 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/tickets",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Unified CLI, daemon, and TypeScript library for issue tracking across GitHub, GitLab, and Jira.",
   "type": "module",
   "license": "MIT",

package/src/adapters/github.ts

@@ -158,7 +158,9 @@ export class GitHubRepository {
     return toDomain(raw);
   }
 
-  async search(query: string, limit = 50): Promise<Issue[]> {
+  // project is accepted for IssueRepository interface parity but ignored --
+  // GitHub's scope (owner/repo) is fixed at construction, not overridable per call.
+  async search(query: string, limit = 50, _project?: string): Promise<Issue[]> {
     const scope = this.repo ? `repo:${this.owner}/${this.repo}` : `org:${this.owner}`;
     const result = (await this.call((signal) =>
       this.client.rest.search.issuesAndPullRequests({ q: `${scope} ${query}`, per_page: limit, request: { signal } }),

package/src/adapters/gitlab.ts

@@ -141,7 +141,9 @@ export class GitLabRepository {
     return toDomain(raw);
   }
 
-  async search(query: string, limit = 50): Promise<Issue[]> {
+  // project is accepted for IssueRepository interface parity but ignored --
+  // GitLab's scope (projectId) is fixed at construction, not overridable per call.
+  async search(query: string, limit = 50, _project?: string): Promise<Issue[]> {
     const raw = await this.call<GlIssue[]>(() =>
       this.client.Issues.all({ projectId: this.projectId, search: query, perPage: limit }),
     );

package/src/adapters/jira.ts

@@ -237,8 +237,9 @@ export class JiraRepository {
     return this.get(key);
   }
 
-  async search(query: string, limit = 50): Promise<Issue[]> {
-    const scope = this.project ? `project = ${jqlQuote(this.project)} AND ` : "";
+  async search(query: string, limit = 50, project?: string): Promise<Issue[]> {
+    const effectiveProject = project ?? this.project;
+    const scope = effectiveProject ? `project = ${jqlQuote(effectiveProject)} AND ` : "";
     const jql = `${scope}text ~ ${jqlQuote(query)} ORDER BY created DESC`;
     return this.searchJql(jql, limit);
   }
@@ -266,9 +267,12 @@ export class JiraRepository {
   private async searchJql(jql: string, limit: number): Promise<Issue[]> {
     // searchForIssuesUsingJqlPost hits the deprecated /rest/api/2/search, which
     // Atlassian has sunset on Jira Cloud (410 Gone). The enhanced variant posts
-    // to the still-live /rest/api/2/search/jql with an identical request/response shape.
+    // to the still-live /rest/api/2/search/jql -- but unlike the old endpoint
+    // (which defaulted to *navigable fields), this one defaults to id-only, so
+    // toDomain() would crash on a missing summary/status/etc. without an explicit
+    // fields request. "*all" restores the old behavior (including custom fields).
     const result = await this.call<{ issues?: JiraIssue[] }>(() =>
-      this.client.issueSearch.searchForIssuesUsingJqlEnhancedSearchPost({ jql, maxResults: limit }),
+      this.client.issueSearch.searchForIssuesUsingJqlEnhancedSearchPost({ jql, maxResults: limit, fields: ["*all"] }),
     );
     return (result?.issues ?? []).map((raw) => this.toDomain(raw));
   }

package/src/application/service.ts

@@ -77,8 +77,8 @@ export class TicketService {
     return this.repo(backend).update(key, input);
   }
 
-  async search(backend: string, query: string, limit?: number): Promise<Issue[]> {
-    return this.repo(backend).search(query, limit);
+  async search(backend: string, query: string, limit?: number, project?: string): Promise<Issue[]> {
+    return this.repo(backend).search(query, limit, project);
   }
 
   async children(ref: string): Promise<Issue[]> {

package/src/daemon/ops.ts

@@ -36,7 +36,7 @@ export interface TicketOpInputs extends Record<TicketOperation, unknown> {
   "issue.get": { ref: string };
   "issue.create": { backend: string; input: CreateInput };
   "issue.update": { ref: string; input: UpdateInput };
-  "issue.search": { backend: string; query: string; limit?: number };
+  "issue.search": { backend: string; query: string; limit?: number; project?: string };
   "issue.children": { ref: string };
   "issue.comments": { ref: string };
   "issue.comment_add": { ref: string; body: string };

package/src/daemon/server.ts

@@ -41,7 +41,7 @@ const handlers: { [Op in TicketOperation]: Handler<Op> } = {
   "issue.get": async (deps, input) => ({ issue: await deps.service.get(input.ref) }),
   "issue.create": async (deps, input) => ({ issue: await deps.service.create(input.backend, input.input) }),
   "issue.update": async (deps, input) => ({ issue: await deps.service.update(input.ref, input.input) }),
-  "issue.search": async (deps, input) => ({ issues: await deps.service.search(input.backend, input.query, input.limit) }),
+  "issue.search": async (deps, input) => ({ issues: await deps.service.search(input.backend, input.query, input.limit, input.project) }),
   "issue.children": async (deps, input) => ({ issues: await deps.service.children(input.ref) }),
   "issue.comments": async (deps, input) => ({ comments: await deps.service.comments(input.ref) }),
   "issue.comment_add": async (deps, input) => ({ comment: await deps.service.addComment(input.ref, input.body) }),

package/src/ports/repository.ts

@@ -13,7 +13,8 @@ export interface IssueRepository {
   get(key: string): Promise<Issue>;
   create(input: CreateInput): Promise<Issue>;
   update(key: string, input: UpdateInput): Promise<Issue>;
-  search(query: string, limit?: number): Promise<Issue[]>;
+  /** project: per-call override of this repository's own default/configured project (Jira only; GitHub/GitLab ignore it -- their scope is fixed to the configured repo/project at construction). */
+  search(query: string, limit?: number, project?: string): Promise<Issue[]>;
   listChildren(key: string): Promise<Issue[]>;
 }