trackerctl 0.2.0 → 0.4.0

package/README.md

@@ -28,16 +28,19 @@ bun run build          # bundle to dist/tracker.js (what the npm package ships)
 
 ## Configuration
 
-Copy `tracker.config.example.json` to `tracker.config.json` and fill in your instance:
+In the project root, scaffold a config:
 
 ```sh
-cp tracker.config.example.json tracker.config.json
+tracker init --base-url https://gitlab.example.com --project group/project
+# or `tracker init` alone, then edit the placeholders
 ```
 
-`tracker.config.json` is **gitignored** (it carries instance/project identifiers); the
-committed example holds the shape. The token is also never committed (env var or gitignored
-`.env`). Config discovery walks up from the current directory, so any subdirectory of the
-project works.
+`init` writes `tracker.config.json` and — inside a git repository — git-ignores the
+local-only files (`tracker.config.json`, `.tracker/`, `.env`) so instance and project
+identifiers can never be committed. The committed `tracker.config.example.json` holds the
+same shape if you prefer copying it by hand. The token is also never committed (env var or
+gitignored `.env`). Config discovery walks up from the current directory, so any
+subdirectory of the project works.
 
 ```json
 {
@@ -86,6 +89,7 @@ Read commands serve from a local sqlite cache that auto-syncs when older than
 | `tracker release <id>` | Clear assignee + label, tombstone claim tokens |
 | `tracker close <id> [--reason <text>]` | Close (clears assignee + in-progress label) |
 | `tracker comment <id> <text>` | Post a comment on an item |
+| `tracker attach <id> <file...> [-m <msg>]` | Upload files, reference them from one comment; prints markdown |
 | `tracker spend <id> <duration>` | Add time spent (`1h30m`, `2d`; `-30m` subtracts) |
 | `tracker estimate <id> <duration>` | Set the time estimate (`0` clears it) |
 | `tracker dep <id> --blocked-by <o> \| --blocks <o>` | Add a dependency edge |
@@ -93,6 +97,16 @@ Read commands serve from a local sqlite cache that auto-syncs when older than
 | `tracker remember <key> <text>` | Store a project memory |
 | `tracker forget <key>` | Hide a memory key |
 | `tracker memories [filter]` | List memories (latest per key wins) |
+| `tracker pr create -t <title> --target <b> …` | Open a PR/MR (`mr` is an alias); `-i 42,43` records Closes trailers |
+| `tracker pr status <id>` | State + provider-neutral CI signal (`none\|pending\|green\|red`) |
+| `tracker pr merge <id> [--close-issues]` | Merge; `--close-issues` closes trailer-referenced issues explicitly |
+| `tracker pr comment/comments/close/reopen` | Discuss, reject (`close -m <reason>`), reopen |
+
+Issues and PRs are **separate capability ports**: `provider` selects where issues live,
+`merge_provider` (defaults to `provider`) selects where PRs live — so a Jira + GitHub
+mix needs no core changes, only adapters. Issue closing on merge is always explicit via
+the issues port: GitLab's `Closes #N` magic only fires on default-branch targets, and a
+GitHub PR can never auto-close a Jira issue, so tracker never relies on provider magic.
 
 Examples:
 
@@ -103,6 +117,7 @@ tracker search --state closed                 # state alone is a valid filter
 tracker search "payment timeout" --label backend --state open
 tracker comment 42 "blocked on design review"
 tracker comments 42 --json
+tracker attach 42 before.png after.png -m "reference screenshots"
 tracker spend 42 1h30m                        # durations: w/d/h/m/s, 1d=8h, 1w=5d
 tracker estimate 42 2d
 tracker search checkout --remote --json       # fresher, server-side
@@ -110,6 +125,9 @@ tracker create -t "Ship login" -d "OAuth" --parent 12 --blocked-by 7,9 -l auth,b
 tracker claim 42 && do-the-work || echo "someone else got it"
 tracker close 42 --reason "fixed in MR !17"
 tracker remember deploy-cmd "bun run deploy:prod"
+tracker pr create -t "Fix login" --target dev -i 42 --json
+tracker pr status 5 --json                    # poll for ci green/red
+tracker pr merge 5 --close-issues
 ```
 
 Exit codes: **0** success · **2** domain failure (lost claim race, refused claim, not
@@ -148,6 +166,15 @@ domain refusal (e.g. lost a claim race) — pick different work, don't retry.
 - Inspect:          `tracker show <id> --json`, `tracker children <id> --json`,
                     `tracker epic-status <id> --json`, `tracker comments <id> --json`
 - Discuss:          `tracker comment <id> "<note for humans or other agents>"`
+- Attach evidence:  `tracker attach <id> <files...> -m "<context>" --json` — uploads
+                    screenshots/files and references them from a comment; reuse the
+                    returned markdown in descriptions
+- Open a PR/MR:     `tracker pr create -t "<title>" --target <branch> -i <issue-ids> --json`
+                    (source defaults to the current branch)
+- Watch the CI:     `tracker pr status <id> --json` — poll until `.ci` is "green" or "red"
+- Land it:          `tracker pr merge <id> --close-issues` — also closes the `-i` issues
+                    with a comment explaining why; never rely on provider auto-close
+
 - Track time:       `tracker spend <id> 1h30m` after finishing work (estimate vs spent
                     feeds later evaluations; durations use 1d=8h, -30m subtracts)
 - Project memory:   `tracker remember <key> "<fact>"`, `tracker memories --json`,

package/dist/tracker.js

@@ -2,8 +2,38 @@
 // @bun
 
 // src/cli/index.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { basename, resolve as resolve4 } from "path";
+
+// src/core/merge.ts
+function closesTrailers(issues) {
+  return issues.map((id) => `Closes #${id}`).join(`
+`);
+}
+function parseClosesIssues(description) {
+  const ids = [];
+  for (const m of description.matchAll(/^Closes #(\S+)\s*$/gim)) {
+    if (!ids.includes(m[1]))
+      ids.push(m[1]);
+  }
+  return ids;
+}
+function withClosesTrailers(description, issues) {
+  if (issues.length === 0)
+    return description;
+  return [description, closesTrailers(issues)].filter(Boolean).join(`
+
+`);
+}
+async function mergeAndCloseIssues(merge, issues, prId) {
+  const pr = await merge.prGet(prId);
+  await merge.prMerge(prId);
+  for (const id of pr.closesIssues) {
+    await issues.transition(id, "closed");
+    await issues.comment(id, `closed by merged PR: ${pr.url}`);
+  }
+  return { closed: pr.closesIssues };
+}
 
 // src/errors.ts
 class DomainError extends Error {
@@ -52,7 +82,7 @@ class GitLabClient {
         ...init,
         headers: {
           Authorization: `Bearer ${this.token}`,
-          "Content-Type": "application/json",
+          ...init.body instanceof FormData ? {} : { "Content-Type": "application/json" },
           ...init.headers ?? {}
         }
       });
@@ -101,6 +131,11 @@ class GitLabClient {
     }
     return all;
   }
+  async upload(path, form) {
+    const url = `${this.baseUrl}/api/v4/${path.replace(/^\//, "")}`;
+    const res = await this.request(url, { method: "POST", body: form });
+    return await res.json();
+  }
   async graphql(query, variables = {}) {
     const res = await this.request(`${this.baseUrl}/api/graphql`, {
       method: "POST",
@@ -207,10 +242,35 @@ mutation trackerWorkItemSetParent($input: WorkItemUpdateInput!) {
     workItem { id }
   }
 }`;
+function mapCiStatus(status) {
+  if (!status)
+    return "none";
+  if (status === "success")
+    return "green";
+  if (status === "failed" || status === "canceled")
+    return "red";
+  return "pending";
+}
+function mapMr(mr) {
+  return {
+    id: String(mr.iid),
+    title: mr.title,
+    state: mr.state === "merged" ? "merged" : mr.state === "opened" ? "open" : "closed",
+    source: mr.source_branch,
+    target: mr.target_branch,
+    draft: mr.draft ?? /^draft:/i.test(mr.title),
+    ci: mapCiStatus(mr.head_pipeline?.status),
+    closesIssues: parseClosesIssues(mr.description ?? ""),
+    url: mr.web_url,
+    description: mr.description ?? "",
+    updatedAt: mr.updated_at
+  };
+}
 
 class GitLabAdapter {
   provider = "gitlab";
   client;
+  baseUrl;
   projectRef;
   fullPath;
   nativeBlocking;
@@ -222,6 +282,7 @@ class GitLabAdapter {
       token: opts.token,
       fetchImpl: opts.fetchImpl
     });
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
     this.projectRef = encodeURIComponent(opts.project);
     this.fullPath = /^\d+$/.test(opts.project) ? null : opts.project;
     this.nativeBlocking = opts.nativeBlocking;
@@ -477,6 +538,94 @@ class GitLabAdapter {
       createdAt: n.created_at
     }));
   }
+  async prCreate(draft) {
+    const title = draft.draft && !/^draft:/i.test(draft.title) ? `Draft: ${draft.title}` : draft.title;
+    const mr = await this.client.rest(`projects/${this.projectRef}/merge_requests`, {
+      method: "POST",
+      body: {
+        title,
+        source_branch: draft.source,
+        target_branch: draft.target,
+        description: withClosesTrailers(draft.description ?? "", draft.issues ?? [])
+      }
+    });
+    return mapMr(mr);
+  }
+  async prGet(id) {
+    try {
+      const mr = await this.client.rest(`projects/${this.projectRef}/merge_requests/${id}`);
+      return mapMr(mr);
+    } catch (e) {
+      if (e instanceof GitLabHttpError && e.status === 404) {
+        throw new DomainError(`PR !${id} not found`);
+      }
+      throw e;
+    }
+  }
+  async prMerge(id) {
+    try {
+      await this.client.rest(`projects/${this.projectRef}/merge_requests/${id}/merge`, {
+        method: "PUT"
+      });
+    } catch (e) {
+      if (e instanceof GitLabHttpError && [405, 406, 409, 422].includes(e.status)) {
+        throw new DomainError(`GitLab refuses to merge !${id}: ${e.message}`);
+      }
+      throw e;
+    }
+  }
+  async prComment(id, body) {
+    await this.client.rest(`projects/${this.projectRef}/merge_requests/${id}/notes`, {
+      method: "POST",
+      body: { body }
+    });
+  }
+  async prListComments(id) {
+    const notes = await this.client.rest(`projects/${this.projectRef}/merge_requests/${id}/notes`, { query: { sort: "asc", order_by: "created_at" }, paginate: true });
+    return notes.filter((n) => !n.system).map((n) => ({
+      id: String(n.id),
+      body: n.body,
+      author: mapUser(n.author),
+      createdAt: n.created_at
+    }));
+  }
+  async prStateEvent(id, event) {
+    try {
+      await this.client.rest(`projects/${this.projectRef}/merge_requests/${id}`, {
+        method: "PUT",
+        body: { state_event: event }
+      });
+    } catch (e) {
+      if (e instanceof GitLabHttpError && e.status === 422) {
+        throw new DomainError(`cannot ${event} PR !${id}: ${e.message}`);
+      }
+      throw e;
+    }
+  }
+  async prClose(id) {
+    return this.prStateEvent(id, "close");
+  }
+  async prReopen(id) {
+    return this.prStateEvent(id, "reopen");
+  }
+  async attach(id, files, message) {
+    const attachments = [];
+    for (const file of files) {
+      const form = new FormData;
+      form.set("file", new Blob([file.content]), file.filename);
+      const up = await this.client.upload(`projects/${this.projectRef}/uploads`, form);
+      attachments.push({
+        filename: file.filename,
+        url: `${this.baseUrl}${up.full_path ?? up.url}`,
+        markdown: up.markdown
+      });
+    }
+    const body = [message, ...attachments.map((a) => a.markdown)].filter(Boolean).join(`
+
+`);
+    await this.comment(id, body);
+    return attachments;
+  }
   async searchRemote(q) {
     const state = q.state ?? "all";
     const issues = await this.client.rest(`projects/${this.projectRef}/issues`, {
@@ -728,6 +877,9 @@ function parseConfig(json, rootDir) {
   if (raw.provider !== "gitlab") {
     throw new UsageError(`unsupported provider "${raw.provider}" (only "gitlab" for now)`);
   }
+  if ((raw.merge_provider ?? raw.provider) !== "gitlab") {
+    throw new UsageError(`unsupported merge_provider "${raw.merge_provider}" (only "gitlab" for now)`);
+  }
   const g = raw.gitlab ?? {};
   if (!g.base_url)
     throw new UsageError("config: gitlab.base_url is required");
@@ -736,6 +888,7 @@ function parseConfig(json, rootDir) {
   const tokenEnv = g.token_env === undefined ? ["TRACKER_GITLAB_TOKEN"] : Array.isArray(g.token_env) ? g.token_env : [g.token_env];
   return {
     provider: "gitlab",
+    merge_provider: "gitlab",
     gitlab: {
       base_url: g.base_url.replace(/\/+$/, ""),
       project: String(g.project),
@@ -758,7 +911,7 @@ function parseConfig(json, rootDir) {
 function loadConfig(startDir = process.cwd()) {
   const file = findConfigFile(startDir);
   if (!file) {
-    throw new UsageError(`no ${CONFIG_FILENAME} found in ${startDir} or any parent directory \u2014 create one (see README) or cd into the project.`);
+    throw new UsageError(`no ${CONFIG_FILENAME} found in ${startDir} or any parent directory \u2014 run \`tracker init\` to create one, or cd into the project.`);
   }
   return parseConfig(readFileSync2(file, "utf8"), dirname3(file));
 }
@@ -1105,11 +1258,83 @@ async function ensureFresh(adapter, cache, staleMs, nowMs = Date.now(), onSync)
   return true;
 }
 
+// src/init.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname as dirname4, join as join3, resolve as resolve3 } from "path";
+var PLACEHOLDER_URL = "https://gitlab.example.com";
+var PLACEHOLDER_PROJECT = "group/project";
+function configTemplate(baseUrl, project) {
+  const config = {
+    provider: "gitlab",
+    gitlab: {
+      base_url: baseUrl.replace(/\/+$/, ""),
+      project,
+      token_env: ["TRACKER_GITLAB_TOKEN", "GITLAB_PERSONAL_ACCESS_TOKEN"],
+      native_blocking: true
+    },
+    labels: { in_progress: "status::in-progress" },
+    memory: { enabled: true, title: "\uD83D\uDCCC Project Memory", label: "meta::memory" },
+    cache: { path: ".tracker/cache.sqlite", stale_minutes: 15 }
+  };
+  return `${JSON.stringify(config, null, 2)}
+`;
+}
+function ensureIgnored(dir, warnings) {
+  const gitRoot = findGitRoot(dir);
+  if (!gitRoot)
+    return [];
+  const entries = [
+    [CONFIG_FILENAME, join3(dir, CONFIG_FILENAME)],
+    [".tracker/", join3(dir, ".tracker", "cache.sqlite")],
+    [".env", join3(dir, ".env")]
+  ];
+  const added = [];
+  for (const [pattern, path] of entries) {
+    const ignored = isGitIgnored(gitRoot, path);
+    if (ignored === null) {
+      warnings.push(`git not available \u2014 verify ${pattern} is git-ignored yourself`);
+      return added;
+    }
+    if (ignored)
+      continue;
+    const gitignorePath = join3(dir, ".gitignore");
+    const existing = existsSync3(gitignorePath) ? readFileSync3(gitignorePath, "utf8") : "";
+    const prefix = existing && !existing.endsWith(`
+`) ? `
+` : "";
+    appendFileSync2(gitignorePath, `${prefix}${pattern}
+`);
+    added.push(pattern);
+  }
+  return added;
+}
+function initProject(targetDir, opts) {
+  const dir = resolve3(targetDir);
+  const configPath = join3(dir, CONFIG_FILENAME);
+  if (existsSync3(configPath)) {
+    throw new UsageError(`${configPath} already exists \u2014 edit it instead of re-running init`);
+  }
+  const warnings = [];
+  const parentConfig = findConfigFile(dirname4(dir));
+  if (parentConfig) {
+    warnings.push(`a ${CONFIG_FILENAME} already exists in ${dirname4(parentConfig)} \u2014 the one created here will shadow it for everything under ${dir}`);
+  }
+  const placeholders = !opts.baseUrl || !opts.project;
+  writeFileSync(configPath, configTemplate(opts.baseUrl ?? PLACEHOLDER_URL, opts.project ?? PLACEHOLDER_PROJECT));
+  const ignoreAdded = ensureIgnored(dir, warnings);
+  return { configPath, placeholders, ignoreAdded, warnings };
+}
+
 // src/cli/help.ts
 var HELP = `tracker \u2014 multi-backend issue tracking for humans and AI agents
 
 usage: tracker <command> [args]
 
+setup:
+  init [--base-url <url>] [--project <group/project>]
+                             scaffold tracker.config.json + .gitignore entries
+  doctor                     verify config, token, connectivity, capabilities
+
 read commands (local cache, auto-sync when stale; all accept --json):
   sync                       refresh the local cache from the provider
   ready [--parent <id>]      open + unblocked + unassigned + not in-progress
@@ -1121,7 +1346,6 @@ read commands (local cache, auto-sync when stale; all accept --json):
   users <query>              resolve usernames/names to user ids
   whoami                     the authenticated user
   memories [filter]          list project memories
-  doctor                     verify config, token, connectivity, capabilities
 
 write commands:
   create -t <title> [-d <desc>] [--parent <id>] [--epic <id>] [-l a,b]
@@ -1130,6 +1354,8 @@ write commands:
   release <id>               clear assignee/label, tombstone live claim tokens
   close <id> [--reason <text>]
   comment <id> <text>        post a comment on an item
+  attach <id> <file...> [-m <message>]
+                             upload files and attach them via a comment
   spend <id> <duration>      add time spent (1h30m, 45m, 2d; -30m subtracts)
   estimate <id> <duration>   set the time estimate (0 clears it)
   dep <id> --blocked-by <other> | --blocks <other>
@@ -1137,6 +1363,15 @@ write commands:
   remember <key> <text>      store a project memory (key has no whitespace)
   forget <key>               hide a memory key
 
+pull/merge requests ("pr" and "mr" are the same command):
+  pr create -t <title> --target <branch> [--source <branch>] [-d <desc>]
+            [-i <issue-ids>] [--draft] [--json]
+  pr status <id> [--json]    state + provider-neutral ci signal (none|pending|green|red)
+  pr merge <id> [--close-issues]
+  pr comment <id> <text>
+  pr comments <id> [--json]
+  pr close <id> [-m <reason>] | pr reopen <id>
+
 search filters:
   --assignee <user> --author <user> --label <l> --state open|closed|all
   --parent <id> --remote     (text query optional when any filter is given)
@@ -1195,6 +1430,42 @@ Posts a comment on the item. Everything after the id is joined into one
 comment body, so quoting multi-word text is optional.
 
 example: tracker comment 42 "blocked on the design review, see thread"`,
+  attach: `usage: tracker attach <id> <file...> [-m <message>] [--json]
+
+Uploads each file to the provider and posts ONE comment on the item containing
+the optional message plus a markdown reference per file, so the attachments are
+discoverable from the item itself. Prints each file's markdown snippet (reusable
+in descriptions); --json emits [{filename, url, markdown}].
+
+examples:
+  tracker attach 42 before.png after.png -m "reference screenshots"
+  tracker attach 42 design.png --json`,
+  pr: `usage: tracker pr <action> \u2026    (alias: tracker mr)
+
+actions:
+  create -t <title> --target <branch> [--source <branch>] [-d <desc>]
+         [-i <id1,id2>] [--draft] [--json]
+                      open a PR/MR; --source defaults to the current git branch.
+                      -i records "Closes #N" trailers so merge --close-issues
+                      can close those issues explicitly (no provider magic).
+  status <id> [--json]
+                      state (open|merged|closed) + ci signal (none|pending|green|red);
+                      poll this to watch a pipeline.
+  merge <id> [--close-issues]
+                      merge; --close-issues then closes every trailer-referenced
+                      issue via the issue tracker and comments why.
+  comment <id> <text> post a comment
+  comments <id> [--json]
+                      list comments oldest-first
+  close <id> [-m <reason>]
+                      close without merging ("reject"); reason posts as a comment
+  reopen <id>
+
+examples:
+  tracker pr create -t "Fix login" --target dev -i 42 --json
+  tracker pr status 5 --json
+  tracker pr merge 5 --close-issues
+  tracker pr close 5 -m "superseded by !6"`,
   comments: `usage: tracker comments <id> [--json]
 
 Lists the item's comments oldest-first (system notes are filtered out). Claim
@@ -1251,7 +1522,17 @@ example: tracker users mehmet`,
   whoami: "usage: tracker whoami [--json]",
   doctor: `usage: tracker doctor [--json]
 
-Verifies config, token, REST/GraphQL connectivity, capabilities, cache.`
+Verifies config, token, REST/GraphQL connectivity, capabilities, cache.`,
+  init: `usage: tracker init [--base-url <url>] [--project <group/project>]
+
+Scaffolds tracker.config.json in the current directory (placeholders when the
+flags are omitted) and, inside a git repository, git-ignores the local-only
+files (tracker.config.json, .tracker/, .env) so instance and project
+identifiers can never be committed. Refuses to overwrite an existing config.
+
+examples:
+  tracker init --base-url https://gitlab.example.com --project group/project
+  tracker init    # then edit the placeholders in tracker.config.json`
 };
 function commandHelp(cmd) {
   return PER_COMMAND[cmd] ?? HELP;
@@ -1340,8 +1621,8 @@ function buildCtx() {
     token,
     nativeBlocking: config.gitlab.native_blocking
   });
-  const cachePath = resolve3(config.rootDir, config.cache.path);
-  if (!existsSync3(cachePath)) {
+  const cachePath = resolve4(config.rootDir, config.cache.path);
+  if (!existsSync4(cachePath)) {
     const guard = guardCacheIgnored(config.rootDir, cachePath);
     if (guard.action === "added" || guard.action === "warn")
       console.error(`(${guard.detail})`);
@@ -1367,7 +1648,7 @@ async function cmdSync(ctx) {
   const t0 = performance.now();
   const { count } = await syncCache(ctx.adapter, ctx.cache);
   const ms = Math.round(performance.now() - t0);
-  console.log(`synced ${count} items in ${ms}ms \u2192 ${resolve3(ctx.config.rootDir, ctx.config.cache.path)}`);
+  console.log(`synced ${count} items in ${ms}ms \u2192 ${resolve4(ctx.config.rootDir, ctx.config.cache.path)}`);
 }
 async function cmdReady(ctx, args) {
   await freshen(ctx);
@@ -1545,6 +1826,128 @@ async function cmdComment(ctx, args) {
   await ctx.adapter.comment(id, body);
   console.log(`commented on #${id}`);
 }
+async function cmdAttach(ctx, args) {
+  const [idArg, ...paths] = args.positionals;
+  const id = normalizeId(idArg);
+  if (paths.length === 0)
+    throw new UsageError(commandHelp("attach"));
+  const files = paths.map((p) => {
+    if (!existsSync4(p))
+      throw new UsageError(`${p}: no such file`);
+    return { filename: basename(p), content: new Uint8Array(readFileSync4(p)) };
+  });
+  const attachments = await ctx.adapter.attach(id, files, str(args, "--message"));
+  if (args.flags.get("--json"))
+    return printJson(attachments);
+  for (const a of attachments)
+    console.log(a.markdown);
+  console.error(`attached ${attachments.length} file(s) to #${id}`);
+}
+function normalizePrId(raw) {
+  if (!raw)
+    throw new UsageError("PR id is required");
+  return raw.replace(/^[!#]/, "");
+}
+function currentGitBranch() {
+  const proc = Bun.spawnSync(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  const branch = proc.success ? proc.stdout.toString().trim() : "";
+  if (!branch || branch === "HEAD") {
+    throw new UsageError("could not determine the current git branch \u2014 pass --source");
+  }
+  return branch;
+}
+async function cmdPr(ctx, args) {
+  const [action, ...positionals] = args.positionals;
+  const json = args.flags.get("--json");
+  switch (action) {
+    case "create": {
+      const title = str(args, "--title");
+      const target = str(args, "--target");
+      if (!title)
+        throw new UsageError(`--title is required
+
+${commandHelp("pr")}`);
+      if (!target)
+        throw new UsageError(`--target is required
+
+${commandHelp("pr")}`);
+      const pr = await ctx.adapter.prCreate({
+        title,
+        target,
+        source: str(args, "--source") ?? currentGitBranch(),
+        description: str(args, "--description"),
+        draft: args.flags.get("--draft") === true,
+        issues: (str(args, "--issue") ?? "").split(",").filter(Boolean).map((s) => s.replace(/^#/, ""))
+      });
+      if (json)
+        return printJson(pr);
+      console.log(pr.url);
+      console.error(`created PR !${pr.id}: ${pr.source} \u2192 ${pr.target}`);
+      return;
+    }
+    case "status": {
+      const pr = await ctx.adapter.prGet(normalizePrId(positionals[0]));
+      if (json)
+        return printJson(pr);
+      const closes = pr.closesIssues.length ? ` \xB7 closes ${pr.closesIssues.map((i) => `#${i}`).join(",")}` : "";
+      console.log(`!${pr.id} ${pr.state} \xB7 ci ${pr.ci}${pr.draft ? " \xB7 draft" : ""}${closes}`);
+      console.log(pr.url);
+      return;
+    }
+    case "merge": {
+      const id = normalizePrId(positionals[0]);
+      if (args.flags.get("--close-issues")) {
+        const { closed } = await mergeAndCloseIssues(ctx.adapter, ctx.adapter, id);
+        invalidate(ctx);
+        console.log(closed.length ? `merged !${id}, closed ${closed.map((i) => `#${i}`).join(", ")}` : `merged !${id} (no Closes trailers found)`);
+      } else {
+        await ctx.adapter.prMerge(id);
+        console.log(`merged !${id}`);
+      }
+      return;
+    }
+    case "comment": {
+      const id = normalizePrId(positionals[0]);
+      const body = positionals.slice(1).join(" ").trim();
+      if (!body)
+        throw new UsageError(commandHelp("pr"));
+      await ctx.adapter.prComment(id, body);
+      console.log(`commented on !${id}`);
+      return;
+    }
+    case "comments": {
+      const id = normalizePrId(positionals[0]);
+      const comments = await ctx.adapter.prListComments(id);
+      if (json)
+        return printJson(comments);
+      if (comments.length === 0)
+        return console.error(`(no comments on !${id})`);
+      for (const c of comments) {
+        console.log(`@${c.author.username}	${c.createdAt}`);
+        console.log(c.body);
+        console.log("");
+      }
+      return;
+    }
+    case "close": {
+      const id = normalizePrId(positionals[0]);
+      const reason = str(args, "--message");
+      if (reason)
+        await ctx.adapter.prComment(id, reason);
+      await ctx.adapter.prClose(id);
+      console.log(`closed !${id}`);
+      return;
+    }
+    case "reopen": {
+      const id = normalizePrId(positionals[0]);
+      await ctx.adapter.prReopen(id);
+      console.log(`reopened !${id}`);
+      return;
+    }
+    default:
+      throw new UsageError(commandHelp("pr"));
+  }
+}
 async function cmdComments(ctx, args) {
   const id = normalizeId(args.positionals[0]);
   const comments = await ctx.adapter.listComments(id);
@@ -1617,7 +2020,7 @@ async function cmdDoctor(args) {
       name: "config",
       status: "fail",
       detail: e.message,
-      fix: "create tracker.config.json (see README) in the project root"
+      fix: "run `tracker init` in the project root to create tracker.config.json"
     });
   }
   let ctx = null;
@@ -1684,7 +2087,7 @@ async function cmdDoctor(args) {
       status: "ok",
       detail: last ? `${ctx.cache.count()} items, synced ${Math.round((Date.now() - last) / 60000)}m ago` : "empty (run: tracker sync)"
     });
-    const cachePath = resolve3(config.rootDir, config.cache.path);
+    const cachePath = resolve4(config.rootDir, config.cache.path);
     const gitRoot = findGitRoot(config.rootDir);
     if (gitRoot) {
       const ignored = isGitIgnored(gitRoot, cachePath);
@@ -1712,6 +2115,21 @@ all good.`);
   }
   return failed ? 1 : 0;
 }
+function cmdInit(args) {
+  const result = initProject(process.cwd(), {
+    baseUrl: str(args, "--base-url"),
+    project: str(args, "--project")
+  });
+  console.log(`created ${result.configPath}`);
+  for (const pattern of result.ignoreAdded)
+    console.log(`added "${pattern}" to .gitignore`);
+  for (const warning of result.warnings)
+    console.error(`warning: ${warning}`);
+  if (result.placeholders) {
+    console.log("next: edit gitlab.base_url and gitlab.project in the config");
+  }
+  console.log("then: export TRACKER_GITLAB_TOKEN (or add it to .env) and run: tracker doctor");
+}
 var VALUE_FLAGS = {
   ready: { "--parent": "value", "--json": "bool" },
   show: { "--json": "bool" },
@@ -1741,9 +2159,22 @@ var VALUE_FLAGS = {
   users: { "--json": "bool" },
   whoami: { "--json": "bool" },
   doctor: { "--json": "bool" },
+  init: { "--base-url": "value", "--project": "value" },
   memories: { "--json": "bool" },
   comment: {},
   comments: { "--json": "bool" },
+  attach: { "--message": "value", "--json": "bool" },
+  pr: {
+    "--title": "value",
+    "--description": "value",
+    "--source": "value",
+    "--target": "value",
+    "--issue": "value",
+    "--draft": "bool",
+    "--close-issues": "bool",
+    "--message": "value",
+    "--json": "bool"
+  },
   spend: {},
   estimate: {},
   sync: {},
@@ -1761,10 +2192,13 @@ var ALIASES = {
     "--labels": "--label",
     "-m": "--milestone"
   },
-  close: { "-r": "--reason" }
+  close: { "-r": "--reason" },
+  attach: { "-m": "--message" },
+  pr: { "-t": "--title", "-d": "--description", "-m": "--message", "-i": "--issue" }
 };
 async function run(argv) {
-  const [cmd, ...rest] = argv;
+  const [rawCmd, ...rest] = argv;
+  const cmd = rawCmd === "mr" ? "pr" : rawCmd;
   if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
     console.log(HELP);
     return cmd ? 0 : 1;
@@ -1781,6 +2215,10 @@ ${HELP}`);
     return 0;
   }
   const args = parseArgs(rest, spec, ALIASES[cmd] ?? {});
+  if (cmd === "init") {
+    cmdInit(args);
+    return 0;
+  }
   if (cmd === "doctor")
     return cmdDoctor(args);
   const ctx = buildCtx();
@@ -1801,6 +2239,8 @@ ${HELP}`);
     memories: cmdMemories,
     comment: cmdComment,
     comments: cmdComments,
+    attach: cmdAttach,
+    pr: cmdPr,
     spend: cmdSpend,
     estimate: cmdEstimate,
     search: cmdSearch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackerctl",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Multi-backend issue-tracking CLI for humans and AI agents — claim races, dependencies, hierarchy, local FTS search, project memory. GitLab adapter first.",
   "license": "MIT",
   "author": "refo",

package/tracker.config.example.json

@@ -1,5 +1,6 @@
 {
   "provider": "gitlab",
+  "merge_provider": "gitlab",
   "gitlab": {
     "base_url": "https://gitlab.example.com",
     "project": "group/project",