@danypops/tickets 0.7.0 → 0.8.1

package/package.json

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

package/src/adapters/jira.ts

@@ -39,6 +39,10 @@ export interface JiraBasicAuthOptions {
   email: string;
   token: string;
   project?: string;
+  /** Additional project keys the poller's background sync also pools into the ledger, beyond the single default `project` above -- see buildSyncQuery(). */
+  syncProjects?: string[];
+  /** When true, the poller's background sync also pools everything assigned to the authenticated user (JQL `assignee = currentUser()`), regardless of project -- covers projects not listed in `project`/`syncProjects`. */
+  syncMine?: boolean;
   timeoutMs?: number;
   /** Injected in tests instead of a real network call — see axios's AxiosRequestConfig.adapter. */
   axiosAdapter?: AxiosAdapter;
@@ -55,6 +59,8 @@ export interface JiraOAuthOptions {
   accessToken: string;
   cloudId: string;
   project?: string;
+  syncProjects?: string[];
+  syncMine?: boolean;
   timeoutMs?: number;
   axiosAdapter?: AxiosAdapter;
   configDir?: string;
@@ -125,6 +131,8 @@ export class JiraRepository {
   /** Same auth/host config Version2Client was built from -- reused lazily by agileClient() so the Agile API client (board/quickfilter resolution) authenticates identically without duplicating the OAuth-vs-basic branching in the constructor below. */
   private readonly clientConfig: JiraClientConfig;
   private readonly project?: string;
+  private readonly syncProjects: string[];
+  private readonly syncMine: boolean;
   private readonly configDir?: string;
   /** display name (lowercased) -> { fieldId, schema type/items }, populated lazily from client.issueFields.getFields(). */
   private customFieldCache?: Map<string, { id: string; type: string; items?: string }>;
@@ -136,6 +144,8 @@ export class JiraRepository {
   constructor(name: string, opts: JiraOptions) {
     this.name = name;
     this.project = opts.project;
+    this.syncProjects = opts.syncProjects ?? [];
+    this.syncMine = opts.syncMine ?? false;
     this.configDir = opts.configDir;
 
     if (this.configDir) {
@@ -274,6 +284,25 @@ export class JiraRepository {
     return this.searchJql(query, limit);
   }
 
+  /**
+   * SyncScopeExpandable -- widens what the poller's own background sync pools
+   * into the local ledger beyond the single default `project` list() falls
+   * back to: every configured project (default plus syncProjects) ORed with
+   * "assignee = currentUser()" when syncMine is set, so issues assigned to
+   * you in a project nobody thought to list still get pooled. Returns
+   * undefined -- letting the poller fall back to plain list() -- when
+   * neither syncProjects nor syncMine adds anything beyond the default
+   * project's own existing behavior.
+   */
+  buildSyncQuery(): string | undefined {
+    const projects = [...new Set([this.project, ...this.syncProjects].filter((p): p is string => Boolean(p)))];
+    if (projects.length <= 1 && !this.syncMine) return undefined;
+    const clauses: string[] = [];
+    if (projects.length > 0) clauses.push(`project in (${projects.map(jqlQuote).join(", ")})`);
+    if (this.syncMine) clauses.push("assignee = currentUser()");
+    return `${clauses.join(" OR ")} ORDER BY created DESC`;
+  }
+
   /**
    * BoardQuickFilterDiscoverable -- resolves a board's quick filter (the same object
    * a board view's `quickFilter=` URL param and a backlog view's `customFilter=`

package/src/application/service.ts

@@ -14,6 +14,7 @@ import {
   hasFieldDiscovery,
   hasRawQuery,
   hasStatusDiscovery,
+  hasSyncScopeExpansion,
   hasTemplateDiscovery,
   type IssueRepository,
 } from "../ports/repository.js";
@@ -89,6 +90,25 @@ export class TicketService {
     return this.repo(backend).list(filter);
   }
 
+  /**
+   * Fetches issues for the poller's own background sync pass (see
+   * daemon/poller.ts). Prefers a backend's own expanded sync scope
+   * (SyncScopeExpandable -- Jira: multiple configured projects plus
+   * everything assigned to the authenticated user, unioned into one query)
+   * over its plain default-project list() when one is configured; falls
+   * back to list() otherwise, so a backend with no sync scope configured
+   * (or with no such capability at all, e.g. GitHub/GitLab) behaves exactly
+   * as before.
+   */
+  async syncFetch(backend: string, limit: number): Promise<Issue[]> {
+    const repo = this.repo(backend);
+    if (hasSyncScopeExpansion(repo) && hasRawQuery(repo)) {
+      const query = repo.buildSyncQuery();
+      if (query) return repo.runQuery(query, limit);
+    }
+    return repo.list({ limit });
+  }
+
   async get(ref: string): Promise<Issue> {
     const { backend, key } = parseRef(ref);
     return this.repo(backend).get(key);

package/src/cli/index.ts

@@ -40,7 +40,7 @@ program
   .command("list")
   .description("list issues on a backend")
   .requiredOption("-b, --backend <name>", "backend name")
-  .option("--project <key>", "project key/id override (e.g. reach CNF or OCPBUGS on a Jira backend defaulting to another project)")
+  .option("--project <key>", "project key/id override (e.g. reach ENG or OPS on a Jira backend defaulting to another project)")
   .option("--status <status>", "filter by status")
   .option("--assignee <user>", "filter by assignee")
   .option("--label <label...>", "filter by label(s)")
@@ -109,7 +109,7 @@ program
   .command("search <query>")
   .description("search issues on a backend")
   .requiredOption("-b, --backend <name>", "backend name")
-  .option("--project <key>", "project key/id override (e.g. reach CNF or OCPBUGS on a Jira backend defaulting to another project)")
+  .option("--project <key>", "project key/id override (e.g. reach ENG or OPS on a Jira backend defaulting to another project)")
   .option("--limit <n>", "max results", (v) => Number.parseInt(v, 10))
   .action(async (query: string, opts) => {
     await withClient((client) => client.call("issue.search", { backend: opts.backend, query, limit: opts.limit, project: opts.project }));

package/src/config/config.ts

@@ -27,6 +27,10 @@ export interface BackendConfig {
   owner?: string;
   project?: string;
   repo?: string;
+  /** Jira only: additional project keys the background poller also pools into the ledger, beyond the single default `project` above. */
+  syncProjects?: string[];
+  /** Jira only: when true, the background poller also pools everything assigned to the authenticated user, regardless of project. */
+  syncMine?: boolean;
 }
 
 export interface Config {
@@ -58,6 +62,22 @@ function resolveToken(cfg: BackendConfig, env: NodeJS.ProcessEnv, envFallback: s
   return env[envFallback];
 }
 
+/** Config wins over the env var; the env var is a comma-separated list (JIRA_SYNC_PROJECTS=ENG,OPS). */
+function resolveSyncProjects(cfg: BackendConfig, env: NodeJS.ProcessEnv): string[] | undefined {
+  if (cfg.syncProjects) return cfg.syncProjects;
+  const raw = env.JIRA_SYNC_PROJECTS;
+  if (!raw) return undefined;
+  return raw
+    .split(",")
+    .map((p) => p.trim())
+    .filter(Boolean);
+}
+
+function resolveSyncMine(cfg: BackendConfig, env: NodeJS.ProcessEnv): boolean {
+  if (cfg.syncMine !== undefined) return cfg.syncMine;
+  return /^(1|true|yes)$/i.test(env.JIRA_SYNC_MINE ?? "");
+}
+
 /**
  * Resolution order, highest priority first: (1) a running Enigma vault, if
  * one happens to be configured for this backend — entirely optional, never a
@@ -208,6 +228,8 @@ async function createRepository(
           accessToken: auth.token,
           cloudId: auth.extra.cloudId,
           project: cfg.project ?? env.JIRA_PROJECT,
+          syncProjects: resolveSyncProjects(cfg, env),
+          syncMine: resolveSyncMine(cfg, env),
           configDir: configDir(),
         });
       }
@@ -219,6 +241,8 @@ async function createRepository(
         email,
         token: auth.token,
         project: cfg.project ?? env.JIRA_PROJECT,
+        syncProjects: resolveSyncProjects(cfg, env),
+        syncMine: resolveSyncMine(cfg, env),
         configDir: configDir(),
       });
     }

package/src/daemon/poller.ts

@@ -23,7 +23,7 @@ export async function syncOnce(
   const results: { backend: string; synced: number; error?: string }[] = [];
   for (const backend of backends) {
     try {
-      const issues = await service.list(backend, { limit: DEFAULT_SYNC_LIMIT });
+      const issues = await service.syncFetch(backend, DEFAULT_SYNC_LIMIT);
       const synced = ledger.upsertMany(backend, issues);
       results.push({ backend, synced });
       logger?.debug("ledger sync ok", { backend, synced });

package/src/ports/repository.ts

@@ -100,3 +100,20 @@ export interface BoardFilterDiscoverable {
 export function hasBoardFilterDiscovery(repo: IssueRepository): repo is IssueRepository & BoardFilterDiscoverable {
   return typeof (repo as Partial<BoardFilterDiscoverable>).discoverBoardFilterJql === "function";
 }
+
+/**
+ * Optional capability — lets a backend widen what the poller's own background
+ * sync pools into the local ledger beyond list()'s single default-project
+ * filter (Jira: additional named projects, plus everything assigned to the
+ * authenticated user, unioned into one JQL string). Returns undefined when
+ * nothing beyond the default scope is configured, so the poller falls back
+ * to plain list() unchanged. Jira only; GitHub/GitLab have no equivalent
+ * multi-project-plus-assignee query language to expand into.
+ */
+export interface SyncScopeExpandable {
+  buildSyncQuery(): string | undefined;
+}
+
+export function hasSyncScopeExpansion(repo: IssueRepository): repo is IssueRepository & SyncScopeExpandable {
+  return typeof (repo as Partial<SyncScopeExpandable>).buildSyncQuery === "function";
+}

package/src/vehicle/tickets-vehicle.ts

@@ -138,7 +138,7 @@ const OPERATIONS: readonly OperationSpec[] = [
     action: "ledger.search",
     description: "Searches the local pooled-issue ledger (no live backend call).",
     effect: "read",
-    properties: { query: stringProp, limit: numberProp },
+    properties: { query: stringProp, limit: numberProp, backend: stringProp },
     required: ["query"],
   },
   {