@loupekit/mcp 0.10.20 → 0.10.21-next.67

package/dist/index.js

@@ -994,6 +994,455 @@ The element's text, id, aria-label and non-utility classes were all searched. If
   };
 }
 
+// src/tools/handoff.ts
+var NO_THREAD = (id) => `No thread found for \`${id}\`.
+
+Use \`list_comments\` to see the ids.`;
+function createHandoffTools(deps) {
+  return {
+    /**
+     * Mark a thread addressed: it moves to In Review and the human is notified.
+     *
+     * There is no way to resolve a thread through this tool, by design.
+     */
+    async markThreadAddressed({ thread_id, message }) {
+      const thread = await deps.fetchThread(thread_id);
+      if (!thread) return { text: NO_THREAD(thread_id), unavailable: true };
+      await deps.patchThread(thread_id, { status: "in_review" });
+      let posted = "";
+      if (message && message.trim()) {
+        await deps.postMessage(thread_id, {
+          author: { ...deps.agent, type: "agent" },
+          body: message.trim()
+        });
+        posted = " Your note is on the thread.";
+      }
+      return {
+        text: `#${thread_id} \u2192 In Review.${posted}
+
+A person has to look at it now \u2014 that is the only way a thread closes. If there is a preview, put the URL in your note so they can check it in place.`
+      };
+    },
+    /**
+     * Post a reply without changing the status. For progress notes, questions, and
+     * anything else that is not a handoff.
+     */
+    async addThreadMessage({ thread_id, message }) {
+      if (!message || !message.trim()) {
+        return { text: "A message body is required \u2014 there is nothing to post.", unavailable: true };
+      }
+      const thread = await deps.fetchThread(thread_id);
+      if (!thread) return { text: NO_THREAD(thread_id), unavailable: true };
+      await deps.postMessage(thread_id, { author: { ...deps.agent, type: "agent" }, body: message.trim() });
+      return {
+        text: `Posted to #${thread_id} as ${deps.agent.name}. The status is unchanged (${thread.status}).`
+      };
+    },
+    /** The full conversation: the original request as message #1, then the replies. */
+    async getThreadConversation({ thread_id }) {
+      const thread = await deps.fetchThread(thread_id);
+      if (!thread) return { text: NO_THREAD(thread_id), unavailable: true };
+      const replies = await deps.listMessages(thread_id);
+      const lines = [
+        `# #${thread_id} \u2014 ${thread.title ?? thread.body.split("\n")[0] ?? ""}`,
+        "",
+        `Status: ${thread.status} \xB7 ${replies.length} repl${replies.length === 1 ? "y" : "ies"}`,
+        "",
+        `**${thread.author.name}** (original request):`,
+        "",
+        thread.body
+      ];
+      for (const r of replies) {
+        lines.push("", `**${r.author.name}** (${r.author.type}) \u2014 ${r.createdAt}:`, "", r.body);
+      }
+      if (!replies.length) lines.push("", "_No replies yet._");
+      return { text: lines.join("\n") };
+    }
+  };
+}
+
+// src/tools/create-pr.ts
+var FIXES_SENTINEL = "<!-- loupe:fixes -->";
+var PR_TITLE = "Feedback Fixes";
+function cell(text) {
+  return text.replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+}
+function fixRow(row) {
+  const commit = row.commit ? `\`${row.commit.slice(0, 7)}\`` : "\u2014";
+  return `| \`${cell(row.threadId)}\` | ${cell(row.description)} | ${commit} |`;
+}
+var TABLE_HEADER = ["| Thread | Fix | Commit |", "| --- | --- | --- |"].join("\n");
+function initialPrBody(opts = {}) {
+  const rows = opts.rows ?? [];
+  return [
+    opts.intro ?? "Fixes from your team's feedback. Each row is one thread.",
+    "",
+    "## Fixes",
+    "",
+    TABLE_HEADER,
+    ...rows.map(fixRow),
+    "",
+    FIXES_SENTINEL,
+    ""
+  ].join("\n");
+}
+function appendFixRow(body, row, opts = {}) {
+  const line = fixRow(row);
+  const at = body.indexOf(FIXES_SENTINEL);
+  const withNote = opts.revisionNote ? `${line}
+
+> ${opts.revisionNote}` : line;
+  if (at < 0) {
+    return `${body.replace(/\s*$/, "")}
+
+${withNote}
+
+${FIXES_SENTINEL}
+`;
+  }
+  const before = body.slice(0, at);
+  const after = body.slice(at);
+  return `${before.replace(/\s*$/, "")}
+${withNote}
+
+${after}`;
+}
+function countFixRows(body) {
+  const at = body.indexOf(FIXES_SENTINEL);
+  const scope = at >= 0 ? body.slice(0, at) : body;
+  return scope.split("\n").filter((l) => /^\|\s*`[^`]+`\s*\|/.test(l)).length;
+}
+function branchNameFor(args) {
+  if (args.branchName) return args.branchName;
+  if (args.revisionOf) return `revision-${args.revisionOf}`;
+  return "loupe/fixes";
+}
+var CreatePrError = class extends Error {
+};
+async function createPrForThread(deps, args) {
+  const doFetch = deps.fetchImpl ?? fetch;
+  if (!args.files.length) throw new CreatePrError("no file changes were given, so there is nothing to open a PR for");
+  const base = args.baseBranch ?? "main";
+  const branch = branchNameFor(args);
+  const api2 = async (path, init) => {
+    const res = await doFetch(`${deps.apiBase.replace(/\/$/, "")}${path}`, {
+      ...init,
+      headers: { "Content-Type": "application/json", "X-Loupe-Admin": deps.adminKey, ...init?.headers ?? {} }
+    });
+    if (!res.ok) throw new CreatePrError(`${init?.method ?? "GET"} ${path} \u2192 ${res.status}`);
+    return res.status === 204 ? null : res.json();
+  };
+  const existing = await api2(
+    `/v1/working-branches?projectKey=${encodeURIComponent(deps.projectKey)}&repo=${encodeURIComponent(args.repo)}`
+  );
+  const tracked = existing.find((b) => b.branch === branch) ?? null;
+  let startFresh = tracked === null || !!args.revisionOf;
+  let outcome = "created";
+  if (tracked && !args.revisionOf) {
+    const stillOpen = tracked.prNumber ? await deps.github.isPullRequestOpen(args.repo, tracked.prNumber) : false;
+    if (stillOpen) {
+      startFresh = false;
+      outcome = "appended";
+    } else {
+      await api2("/v1/working-branches", {
+        method: "POST",
+        body: JSON.stringify({
+          projectKey: deps.projectKey,
+          repo: args.repo,
+          branch,
+          status: "merged",
+          prNumber: tracked.prNumber
+        })
+      });
+      startFresh = true;
+      outcome = "restarted";
+    }
+  }
+  const row = { threadId: args.threadId, description: args.description };
+  if (startFresh) {
+    const commit2 = await deps.github.commitChanges(args.repo, branch, commitMessage(args, false), args.files, { base });
+    row.commit = commit2.sha;
+    const intro = args.revisionOf ? `Revision of thread \`${args.revisionOf}\`. The conversation and the original element context carry over.` : void 0;
+    const pr2 = await deps.github.createPullRequest(args.repo, {
+      title: PR_TITLE,
+      head: branch,
+      base,
+      body: initialPrBody({ rows: [row], intro })
+    });
+    await api2("/v1/working-branches", {
+      method: "POST",
+      body: JSON.stringify({
+        projectKey: deps.projectKey,
+        repo: args.repo,
+        branch,
+        baseBranch: base,
+        status: "open",
+        headSha: commit2.sha,
+        prNumber: pr2.number,
+        prUrl: pr2.htmlUrl,
+        addFix: true,
+        description: args.description
+      })
+    });
+    return {
+      outcome,
+      repo: args.repo,
+      branch,
+      commit: commit2.sha,
+      prNumber: pr2.number,
+      prUrl: pr2.htmlUrl,
+      fixCount: 1,
+      note: `Opened ${pr2.htmlUrl} on a new branch \`${branch}\` with this fix as its first commit.`
+    };
+  }
+  const commit = await deps.github.commitChanges(args.repo, branch, commitMessage(args, true), args.files);
+  row.commit = commit.sha;
+  const pr = await deps.github.getPullRequest(args.repo, tracked.prNumber);
+  const body = appendFixRow(
+    pr.body,
+    row,
+    args.revisionOf ? { revisionNote: `Revision of thread \`${args.revisionOf}\`.` } : {}
+  );
+  await deps.github.updatePullRequestBody(args.repo, pr.number, body);
+  const record = await api2("/v1/working-branches", {
+    method: "POST",
+    body: JSON.stringify({
+      projectKey: deps.projectKey,
+      repo: args.repo,
+      branch,
+      status: "open",
+      headSha: commit.sha,
+      addFix: true,
+      description: args.description
+    })
+  });
+  return {
+    outcome,
+    repo: args.repo,
+    branch,
+    commit: commit.sha,
+    prNumber: pr.number,
+    prUrl: pr.htmlUrl,
+    fixCount: countFixRows(body) || record.fixCount,
+    note: `Appended this fix to ${pr.htmlUrl} as commit \`${commit.sha.slice(0, 7)}\` \u2014 one PR, now ${countFixRows(body) || record.fixCount} fix${(countFixRows(body) || record.fixCount) === 1 ? "" : "es"}.`
+  };
+}
+function commitMessage(args, appending) {
+  const verb = appending ? "fix" : "feat";
+  const scope = args.repo.split("/")[1] ?? "app";
+  return `${verb}(${scope}): ${args.description}
+
+Addresses feedback thread ${args.threadId}.`;
+}
+
+// src/github/github-client.ts
+import { execFileSync } from "child_process";
+var DEFAULT_UA = "loupe-mcp (+https://github.com/mohamed-ashraf-elsaed/loupe)";
+var PLACEHOLDER_PATTERNS = [
+  /^<.*>$/,
+  // <your token>
+  /(your|my|the)[\s._-]*(gh|github)?[\s._-]*(pat|token|key|secret)/,
+  /^(?:x{4,}|y{4,}|z{4,}|0{4,}|\.{3,}|-{4,}|\*{4,})$/,
+  /(change[\s._-]?me|placeholder|replace[\s._-]?me|todo|tbd)/,
+  /\.\.\./
+];
+function isPlaceholderToken(token) {
+  if (token == null) return true;
+  const t = token.trim();
+  if (!t) return true;
+  if (t.length < 20) return true;
+  const lower = t.toLowerCase();
+  return PLACEHOLDER_PATTERNS.some((re) => re.test(lower));
+}
+var NO_TOKEN_MESSAGE = "No GitHub token is configured, so I cannot open a pull request.\n\nSet `GITHUB_TOKEN` in the MCP server's environment (a fine-grained PAT with Contents and Pull requests: read and write on the repository), or run `gh auth login`. Everything else works without it \u2014 the fix is still recorded on the thread.";
+function resolveGitHubToken(opts = {}) {
+  const env = opts.env ?? process.env;
+  const explicit = env.GITHUB_TOKEN ?? env.GH_TOKEN;
+  if (explicit && !isPlaceholderToken(explicit)) {
+    return { token: explicit.trim(), source: "env", message: "Using GITHUB_TOKEN from the environment." };
+  }
+  const read = opts.readGhToken ?? readGhCliToken;
+  const fromCli = read();
+  if (fromCli && !isPlaceholderToken(fromCli)) {
+    return { token: fromCli.trim(), source: "gh-cli", message: "Using the token from `gh auth token`." };
+  }
+  if (explicit) {
+    return {
+      token: null,
+      source: "none",
+      message: `GITHUB_TOKEN looks like a placeholder, so it was ignored. ${NO_TOKEN_MESSAGE}`
+    };
+  }
+  return { token: null, source: "none", message: NO_TOKEN_MESSAGE };
+}
+function readGhCliToken() {
+  try {
+    const out = execFileSync("gh", ["auth", "token"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+var GitHubError = class extends Error {
+  status;
+  path;
+  // Explicit fields, not constructor parameter properties: Node runs these files with
+  // type-stripping only, and `constructor(private x)` is rejected there. There is a
+  // test that scans for this pattern, because it has bitten twice.
+  constructor(message, status, path) {
+    super(message);
+    this.name = "GitHubError";
+    this.status = status;
+    this.path = path;
+  }
+};
+var GitHubClient = class {
+  baseUrl;
+  fetchImpl;
+  userAgent;
+  token;
+  constructor(token, opts = {}) {
+    if (isPlaceholderToken(token)) throw new GitHubError("a real GitHub token is required", 0, "constructor");
+    this.token = token.trim();
+    this.baseUrl = (opts.baseUrl ?? "https://api.github.com").replace(/\/$/, "");
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.userAgent = opts.userAgent ?? DEFAULT_UA;
+  }
+  async request(method, path, body) {
+    const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": this.userAgent,
+        Authorization: `Bearer ${this.token}`,
+        ...body === void 0 ? {} : { "Content-Type": "application/json" }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      let detail = text;
+      try {
+        detail = JSON.parse(text).message ?? text;
+      } catch {
+      }
+      throw new GitHubError(this.redact(`${method} ${path} \u2192 ${res.status}: ${detail}`), res.status, path);
+    }
+    return text ? JSON.parse(text) : null;
+  }
+  /** Belt and braces: the token must never reach a log or a tool result. */
+  redact(text) {
+    return this.token ? text.split(this.token).join("[redacted]") : text;
+  }
+  // ---- branches -------------------------------------------------------------
+  async branchExists(repo, branch) {
+    try {
+      await this.request("GET", `/repos/${repo}/git/ref/heads/${encodeURIComponent(branch)}`);
+      return true;
+    } catch (e) {
+      if (e instanceof GitHubError && e.status === 404) return false;
+      throw e;
+    }
+  }
+  /** The commit sha a branch points at. */
+  async branchHead(repo, branch) {
+    const ref = await this.request(
+      "GET",
+      `/repos/${repo}/git/ref/heads/${encodeURIComponent(branch)}`
+    );
+    return ref.object.sha;
+  }
+  /** Create a branch from another, resolving the base to its current commit. */
+  async createBranchFromBase(repo, branch, base) {
+    const sha = await this.branchHead(repo, base);
+    await this.request("POST", `/repos/${repo}/git/refs`, { ref: `refs/heads/${branch}`, sha });
+    return sha;
+  }
+  // ---- commits --------------------------------------------------------------
+  /**
+   * Land every file change as exactly **one** commit on `branch`, creating the branch
+   * from `base` first when it does not exist.
+   *
+   * blob(s) → tree → commit → ref, in that order, so a partial failure leaves the
+   * repository untouched rather than half-updated.
+   */
+  async commitChanges(repo, branch, message, changes, opts = {}) {
+    if (!changes.length) throw new GitHubError("no file changes to commit", 0, "commitChanges");
+    const created = !await this.branchExists(repo, branch);
+    let parentSha;
+    if (created) {
+      const base = opts.base;
+      if (!base) throw new GitHubError(`branch ${branch} does not exist and no base was given`, 0, "commitChanges");
+      parentSha = await this.createBranchFromBase(repo, branch, base);
+    } else {
+      parentSha = await this.branchHead(repo, branch);
+    }
+    const parent = await this.request("GET", `/repos/${repo}/git/commits/${parentSha}`);
+    const blobs = await Promise.all(changes.map(async (change) => {
+      const blob = await this.request("POST", `/repos/${repo}/git/blobs`, {
+        content: change.content,
+        encoding: "utf-8"
+      });
+      return { path: change.path, mode: "100644", type: "blob", sha: blob.sha };
+    }));
+    const tree = await this.request("POST", `/repos/${repo}/git/trees`, {
+      base_tree: parent.tree.sha,
+      tree: blobs
+    });
+    const commit = await this.request("POST", `/repos/${repo}/git/commits`, {
+      message,
+      tree: tree.sha,
+      parents: [parentSha]
+    });
+    await this.request("PATCH", `/repos/${repo}/git/refs/heads/${encodeURIComponent(branch)}`, { sha: commit.sha });
+    return { sha: commit.sha, created, files: changes.length };
+  }
+  // ---- pull requests --------------------------------------------------------
+  async createPullRequest(repo, opts) {
+    const pr = await this.request("POST", `/repos/${repo}/pulls`, {
+      title: opts.title,
+      head: opts.head,
+      base: opts.base,
+      body: opts.body ?? "",
+      draft: opts.draft ?? false
+    });
+    return toPullRequest(pr);
+  }
+  async getPullRequest(repo, number) {
+    return toPullRequest(await this.request("GET", `/repos/${repo}/pulls/${number}`));
+  }
+  /** The PR body, for appending a fix to an accumulating PR. */
+  async getPullRequestBody(repo, number) {
+    return (await this.getPullRequest(repo, number)).body;
+  }
+  async updatePullRequestBody(repo, number, body) {
+    await this.request("PATCH", `/repos/${repo}/pulls/${number}`, { body });
+  }
+  async isPullRequestOpen(repo, number) {
+    return (await this.getPullRequest(repo, number)).state === "open";
+  }
+  /** Find an open PR for a branch, if there is one. */
+  async findOpenPullRequest(repo, head, base) {
+    const q = new URLSearchParams({ head: `${repo.split("/")[0]}:${head}`, state: "open" });
+    if (base) q.set("base", base);
+    const list = await this.request("GET", `/repos/${repo}/pulls?${q}`);
+    return list.length ? toPullRequest(list[0]) : null;
+  }
+};
+function toPullRequest(raw) {
+  return {
+    number: raw.number,
+    url: raw.url,
+    htmlUrl: raw.html_url,
+    state: raw.state,
+    head: raw.head?.ref ?? "",
+    base: raw.base?.ref ?? "",
+    title: raw.title ?? "",
+    body: raw.body ?? ""
+  };
+}
+
 // index.ts
 import {
   CHANGE_TYPE_LABELS,
@@ -1163,7 +1612,7 @@ async function proposeChange({ id, html, css, notes }) {
   bus.publishThread(id, "preview_live", { author: proposal.author });
   return wrap(`Proposal saved for #${id}. The dev team can now review your modified HTML/CSS in the dashboard.`);
 }
-var server = new McpServer({ name: "loupe", version: "0.10.20" });
+var server = new McpServer({ name: "loupe", version: "0.10.21" });
 server.tool(
   "list_comments",
   "List Loupe product-feedback comments for the project as a task backlog. Each item carries its board stage, priority and change type, so you can start with the most urgent. Use this to see what a PM has flagged, then work through the items.",
@@ -1201,17 +1650,18 @@ server.tool(
   proposeChange
 );
 var WS = process.env.LOUPE_WORKSPACE || process.cwd();
+async function fetchThreadById(id) {
+  try {
+    return await api(`/v1/comments/${encodeURIComponent(id)}`);
+  } catch {
+    return null;
+  }
+}
 var elementTools = createElementContextTools({
   store,
   workspaceRoot: WS,
   mapperOptions: { maxFiles: Number(process.env.LOUPE_MAP_MAX_FILES ?? 4e3) },
-  fetchThread: async (id) => {
-    try {
-      return await api(`/v1/comments/${encodeURIComponent(id)}`);
-    } catch {
-      return null;
-    }
-  }
+  fetchThread: fetchThreadById
 });
 var SELECTION_ARGS = {
   thread_id: z.string().optional().describe("Work from a stored comment instead of a live selection."),
@@ -1246,6 +1696,101 @@ server.tool(
   SELECTION_ARGS,
   async ({ thread_id, selection_id }) => wrap((await elementTools.findSourceForSelection({ thread_id, selection_id })).text)
 );
+var AGENT = {
+  id: process.env.LOUPE_AGENT_ID || "loupe-agent",
+  name: process.env.LOUPE_AGENT_NAME || "Claude Code"
+};
+var handoff = createHandoffTools({
+  agent: AGENT,
+  fetchThread: fetchThreadById,
+  patchThread: async (id, patch) => {
+    await api(`/v1/comments/${encodeURIComponent(id)}`, { method: "PATCH", body: JSON.stringify(patch) });
+  },
+  postMessage: async (threadId, message) => await api(`/v1/comments/${encodeURIComponent(threadId)}/messages`, {
+    method: "POST",
+    body: JSON.stringify(message)
+  }),
+  listMessages: async (threadId) => await api(`/v1/comments/${encodeURIComponent(threadId)}/messages`)
+});
+server.tool(
+  "mark_thread_addressed",
+  "Hand a thread back to a human: it moves to In Review and, optionally, posts your closing note. Use this when the change is ready. It CANNOT resolve a thread \u2014 only a person does that \u2014 which is why there is no status argument.",
+  {
+    thread_id: z.string().describe("The thread you have addressed."),
+    message: z.string().optional().describe("A short note for the reviewer \u2014 what changed and where to look. Include a preview URL if there is one.")
+  },
+  async ({ thread_id, message }) => wrap((await handoff.markThreadAddressed({ thread_id, message })).text)
+);
+server.tool(
+  "add_thread_message",
+  "Reply on a thread without changing its status \u2014 progress notes, questions, or the preview URL when it goes live. The status is left exactly as it was.",
+  {
+    thread_id: z.string(),
+    message: z.string().describe("Markdown. Say something useful; a person reads this.")
+  },
+  async ({ thread_id, message }) => wrap((await handoff.addThreadMessage({ thread_id, message })).text)
+);
+server.tool(
+  "get_thread_conversation",
+  "The whole conversation on a thread: the original request, then every reply with its author. Read it before answering so you are not repeating something already said.",
+  { thread_id: z.string() },
+  async ({ thread_id }) => wrap((await handoff.getThreadConversation({ thread_id })).text)
+);
+server.tool(
+  "create_pr_for_thread",
+  "Open a pull request for a fix \u2014 or, more usually, add it to the one the repo already has. One working branch per repo accumulates every fix as its own commit, and the PR body keeps a table of them. If that PR was merged or closed, a fresh branch is started automatically. Use `get_element_context` first to find the file, then pass the full new contents of each file you changed.",
+  {
+    repo: z.string().describe('Owner/name, e.g. "acme/web".'),
+    thread_id: z.string().describe("The thread this fix answers."),
+    description: z.string().describe('One line for the PR table, e.g. "larger checkout button".'),
+    files: z.array(z.object({
+      path: z.string().describe("Path within the repo."),
+      content: z.string().describe("The file's FULL new contents, not a diff.")
+    })).min(1).describe("Every file you changed. They land as one atomic commit."),
+    base_branch: z.string().optional().describe('What to branch from. Defaults to "main".'),
+    branch_name: z.string().optional().describe("Override the branch name. Rarely needed."),
+    revision_of: z.string().optional().describe("Set to a thread id when this is a revision \u2014 it gets its own revision-* branch rather than joining the accumulating one.")
+  },
+  async (args) => {
+    const resolved = resolveGitHubToken();
+    if (!resolved.token) return wrap(resolved.message);
+    try {
+      const result = await createPrForThread(
+        { github: new GitHubClient(resolved.token), apiBase: API, adminKey: ADMIN, projectKey: PROJECT_KEY },
+        {
+          repo: args.repo,
+          threadId: args.thread_id,
+          description: args.description,
+          files: args.files,
+          baseBranch: args.base_branch,
+          branchName: args.branch_name,
+          revisionOf: args.revision_of
+        }
+      );
+      await api(`/v1/comments/${encodeURIComponent(args.thread_id)}`, {
+        method: "PATCH",
+        body: JSON.stringify({ pr: { number: result.prNumber, url: result.prUrl, state: "open" } })
+      });
+      bus.publishThread(args.thread_id, "pr_created", {
+        number: result.prNumber,
+        url: result.prUrl,
+        branch: result.branch,
+        commit: result.commit
+      });
+      return wrap(
+        `#${args.thread_id} \u2192 ${result.prUrl}
+
+${result.note}
+
+Branch \`${result.branch}\` \xB7 commit \`${result.commit.slice(0, 7)}\` \xB7 outcome: ${result.outcome}.
+The thread's status is unchanged \u2014 call \`mark_thread_addressed\` when the change is ready for review.`
+      );
+    } catch (e) {
+      const text = e instanceof GitHubError || e instanceof CreatePrError ? e.message : String(e);
+      return wrap(`Could not open the pull request: ${text}`);
+    }
+  }
+);
 function isEntrypoint() {
   try {
     return import.meta.url === pathToFileURL(realpathSync(argv[1] ?? "")).href;

package/package.json

@@ -5,7 +5,7 @@
     "email": "m.ashraf.saed@gmail.com",
     "url": "https://www.linkedin.com/in/mohamedashrafelsaed/"
   },
-  "version": "0.10.20",
+  "version": "0.10.21-next.67",
   "description": "MCP server that exposes Loupe comments to Claude Code as an actionable, fully-contextualized backlog.",
   "keywords": [
     "loupe",
@@ -46,6 +46,6 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@loupekit/shared": "0.10.20"
+    "@loupekit/shared": "0.10.21-next.67"
   }
 }