@super-one/cli 0.68.0-alpha → 0.68.0-alpha.1

package/MANIFEST.json

@@ -1,7 +1,7 @@
 {
   "name": "@super-one/cli",
-  "version": "0.68.0-alpha",
+  "version": "0.68.0-alpha.1",
   "kind": "npm",
   "minNodeMajor": 20,
-  "builtAt": "2026-09-21T12:48:30.717Z"
+  "builtAt": "2026-09-21T16:44:42.858Z"
 }

package/lib/cli.mjs

@@ -14752,10 +14752,126 @@ var init_capability_prompt_tags = __esm({
   }
 });
 
+// ../../packages/shared/src/fuzzy-match.ts
+function forwardMatchFrom(queryLower, textLower, start) {
+  const indices = [];
+  let qi2 = 0;
+  for (let pi2 = start; pi2 < textLower.length && qi2 < queryLower.length; pi2++) {
+    if (textLower[pi2] === queryLower[qi2]) {
+      indices.push(pi2);
+      qi2++;
+    }
+  }
+  return indices;
+}
+function scoreIndices(indices, query, text2) {
+  let score = 0;
+  for (let i = 0; i < indices.length; i++) {
+    const idx = indices[i];
+    if (i > 0 && idx === indices[i - 1] + 1) score += 5;
+    if (text2[idx] === query[i]) score += 1;
+  }
+  if (indices.length > 0 && indices[0] === 0) score += 10;
+  score -= text2.length * 0.1;
+  return score;
+}
+function fuzzyMatch(query, text2) {
+  if (!query) return { match: true, score: 0, indices: [] };
+  const queryLower = query.toLowerCase();
+  const textLower = text2.toLowerCase();
+  const fwd = forwardMatchFrom(queryLower, textLower, 0);
+  if (fwd.length < queryLower.length) return { match: false, score: 0, indices: [] };
+  let bestIndices = fwd;
+  let bestScore = scoreIndices(fwd, query, text2);
+  const startPositions = /* @__PURE__ */ new Set();
+  for (let pi2 = 1; pi2 < textLower.length; pi2++) {
+    if (textLower[pi2] === queryLower[0]) startPositions.add(pi2);
+  }
+  for (const start of startPositions) {
+    const candidate = forwardMatchFrom(queryLower, textLower, start);
+    if (candidate.length < queryLower.length) continue;
+    const s4 = scoreIndices(candidate, query, text2);
+    if (s4 > bestScore) {
+      bestScore = s4;
+      bestIndices = candidate;
+    }
+  }
+  return { match: true, score: bestScore, indices: bestIndices };
+}
+var init_fuzzy_match = __esm({
+  "../../packages/shared/src/fuzzy-match.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/git-mention-query.ts
+function gitMentionPortalOf(kind) {
+  return GIT_MENTION_PORTALS.gh.includes(kind) ? "gh" : "git";
+}
+function isGitHubRefKind(kind) {
+  return gitMentionPortalOf(kind) === "gh";
+}
+function isGitMentionRefKind(value) {
+  return typeof value === "string" && GIT_MENTION_REF_KINDS.includes(value);
+}
+function gitRefNameMatches(text2, query) {
+  const q2 = query.trim();
+  if (!q2) return true;
+  return fuzzyMatch(q2, text2).match;
+}
+function titledKind(kind) {
+  return kind === "commit" || isGitHubRefKind(kind);
+}
+function gitRefMatches(ref, query) {
+  return gitRefNameMatches(titledKind(ref.kind) ? ref.detail : ref.label, query);
+}
+var GIT_MENTION_REF_KINDS, GIT_MENTION_PORTALS, GIT_MENTION_KEYWORD, GH_MENTION_KEYWORD, GIT_MENTION_NAV_PREFIX, GH_MENTION_NAV_PREFIX, GIT_HOST_PROVIDERS, GIT_MENTION_REF_LIMIT;
+var init_git_mention_query = __esm({
+  "../../packages/shared/src/git-mention-query.ts"() {
+    "use strict";
+    init_fuzzy_match();
+    GIT_MENTION_REF_KINDS = ["branch", "commit", "worktree", "tag", "issue", "pr"];
+    GIT_MENTION_PORTALS = {
+      git: ["branch", "commit", "worktree", "tag"],
+      gh: ["issue", "pr"]
+    };
+    GIT_MENTION_KEYWORD = "git";
+    GH_MENTION_KEYWORD = "gh";
+    GIT_MENTION_NAV_PREFIX = `${GIT_MENTION_KEYWORD} `;
+    GH_MENTION_NAV_PREFIX = `${GH_MENTION_KEYWORD} `;
+    GIT_HOST_PROVIDERS = ["github"];
+    GIT_MENTION_REF_LIMIT = 50;
+  }
+});
+
+// ../../packages/shared/src/git-mention-tags.ts
+function unescapeGitTagText(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+function gitTagDisplayName(name) {
+  return unescapeGitTagText(name).trim();
+}
+function replaceGitTagsWithMention(text2) {
+  return text2.replace(GIT_TAG_REGEX, (_full, _kind, name) => `@${gitTagDisplayName(String(name))}`).replace(GIT_HOST_TAG_REGEX, (_full, _host, _kind, name) => `@${gitTagDisplayName(String(name))}`);
+}
+var INNER, GIT_TAG_REGEX, GIT_HOST_TAG_REGEX;
+var init_git_mention_tags = __esm({
+  "../../packages/shared/src/git-mention-tags.ts"() {
+    "use strict";
+    init_git_mention_query();
+    INNER = "\\s*<kind>([\\s\\S]*?)<\\/kind>\\s*<name>([\\s\\S]*?)<\\/name>\\s*<id>([\\s\\S]*?)<\\/id>\\s*";
+    GIT_TAG_REGEX = new RegExp(`<superone-git>${INNER}<\\/superone-git>`, "g");
+    GIT_HOST_TAG_REGEX = new RegExp(
+      `<superone-(${GIT_HOST_PROVIDERS.join("|")})>${INNER}<\\/superone-\\1>`,
+      "g"
+    );
+  }
+});
+
 // ../../packages/shared/src/miniapp-prompt-tags.ts
 function stripMiniAppMarkup(text2) {
   return stripCapabilityMarkup(
-    text2.replace(MINIAPP_REMINDER_REGEX, "").replace(SESSION_REMINDER_REGEX, "").replace(DESKTOP_APP_REMINDER_REGEX, "").replace(MINIAPP_TAG_REGEX, (_3, appName) => `@${String(appName).trim()}`).replace(SESSION_TAG_REGEX, (_3, title) => `@${String(title).trim()}`).replace(DESKTOP_APP_TAG_REGEX, (_3, name) => `@${String(name).trim()}`).replace(PATH_REF_TAG_REGEX, (_full, _kind, name, value) => {
+    replaceGitTagsWithMention(text2).replace(MINIAPP_REMINDER_REGEX, "").replace(SESSION_REMINDER_REGEX, "").replace(DESKTOP_APP_REMINDER_REGEX, "").replace(MINIAPP_TAG_REGEX, (_3, appName) => `@${String(appName).trim()}`).replace(SESSION_TAG_REGEX, (_3, title) => `@${String(title).trim()}`).replace(DESKTOP_APP_TAG_REGEX, (_3, name) => `@${String(name).trim()}`).replace(PATH_REF_TAG_REGEX, (_full, _kind, name, value) => {
       const n = String(name).trim();
       const v3 = String(value).trim();
       return `@${n || v3}`;
@@ -14768,6 +14884,7 @@ var init_miniapp_prompt_tags = __esm({
     "use strict";
     init_miniapp_mention_marker();
     init_capability_prompt_tags();
+    init_git_mention_tags();
     MINIAPP_TAG_REGEX = /<superone-miniapp>\s*<appname>([\s\S]*?)<\/appname>\s*<appid>([\s\S]*?)<\/appid>\s*<\/superone-miniapp>/g;
     MINIAPP_REMINDER_REGEX = /\n*<superone-miniapp-reminder>[\s\S]*?<\/superone-miniapp-reminder>\n*/g;
     SESSION_TAG_REGEX = /<superone-session>\s*<title>([\s\S]*?)<\/title>\s*<sessionId>([\s\S]*?)<\/sessionId>\s*<\/superone-session>/g;
@@ -73284,8 +73401,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.68.0-alpha".trim()) {
-    return "0.68.0-alpha".trim();
+  if ("0.68.0-alpha.1".trim()) {
+    return "0.68.0-alpha.1".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -75384,6 +75501,7 @@ async function cloneRepository(input) {
 }
 
 // src/rpc/handlers.ts
+init_git_mention_query();
 import { existsSync as existsSync26, mkdirSync as mkdirSync15, readdirSync as readdirSync9, statSync as statSync6 } from "node:fs";
 import { join as pathJoin, resolve as pathResolve } from "node:path";
 import { arch, cpus, freemem, homedir as homedir7, hostname as hostname4, platform, totalmem, uptime } from "node:os";
@@ -77802,6 +77920,10 @@ async function dispatchRpcInner(method, payload, ctx) {
       return handleGitCreateBranch(payload, ctx);
     case "git.worktrees":
       return handleGitWorktrees(payload, ctx);
+    case "git.mentionRefs":
+      return handleGitMentionRefs(payload, ctx);
+    case "git.mentionCapabilities":
+      return handleGitMentionCapabilities(payload, ctx);
     case "git.worktreeActivate":
       return handleGitWorktreeActivate(payload, ctx);
     case "git.worktreeCheckedOutBranches":
@@ -78855,6 +78977,41 @@ function handleGitCreateBranch(payload, ctx) {
     return mapThrown8(err);
   }
 }
+async function handleGitMentionCapabilities(payload, ctx) {
+  const denied = requireScopes8(ctx.client, OPERATION_SCOPES.readWorkspace);
+  if (denied) return denied;
+  const p3 = asRecord24(payload);
+  try {
+    return {
+      result: await ctx.workspaceGit.mentionCapabilities(
+        String(p3.projectId ?? ""),
+        typeof p3.cwd === "string" ? p3.cwd : null
+      )
+    };
+  } catch (err) {
+    return mapThrown8(err);
+  }
+}
+async function handleGitMentionRefs(payload, ctx) {
+  const denied = requireScopes8(ctx.client, OPERATION_SCOPES.readWorkspace);
+  if (denied) return denied;
+  const p3 = asRecord24(payload);
+  if (!isGitMentionRefKind(p3.kind)) {
+    return { error: { code: "invalid_argument", message: "kind must be branch | commit | worktree | tag | issue | pr" } };
+  }
+  try {
+    return {
+      result: await ctx.workspaceGit.mentionRefs(
+        String(p3.projectId ?? ""),
+        p3.kind,
+        typeof p3.query === "string" ? p3.query : "",
+        typeof p3.cwd === "string" ? p3.cwd : null
+      )
+    };
+  } catch (err) {
+    return mapThrown8(err);
+  }
+}
 function handleGitWorktrees(payload, ctx) {
   const denied = requireScopes8(ctx.client, OPERATION_SCOPES.readWorkspace);
   if (denied) return denied;
@@ -85970,6 +86127,10 @@ function gitErrorMessage(err) {
   if (stderr) return stderr;
   return err?.message ?? "Unknown git error";
 }
+var NOT_A_REPO_RE = /not a git repository/i;
+function isNotGitRepoError(err) {
+  return NOT_A_REPO_RE.test(gitErrorMessage(err));
+}
 
 // ../../packages/runtime/src/git/shortstat.ts
 function parseShortstat(shortstat) {
@@ -86028,6 +86189,220 @@ function gitRunSync(folderPath, args, env) {
   }
 }
 
+// ../../packages/runtime/src/git/mention-refs.ts
+init_git_mention_query();
+
+// ../../packages/runtime/src/git/gh-run.ts
+init_spawn_env();
+import { execFile as execFile4 } from "child_process";
+var GH_MAX_BUFFER = 16 * 1024 * 1024;
+function isGhMissingError(err) {
+  return err?.code === "ENOENT";
+}
+function ghRun(folderPath, args, timeoutMs, env) {
+  return new Promise((resolve17, reject) => {
+    execFile4(
+      "gh",
+      args,
+      {
+        cwd: folderPath,
+        env: { ...env ? buildSafeEnv(env) : process.env, GH_PROMPT_DISABLED: "1", GH_NO_UPDATE_NOTIFIER: "1" },
+        maxBuffer: GH_MAX_BUFFER,
+        timeout: timeoutMs
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const annotated = err;
+          if (stderr && !annotated.stderr) annotated.stderr = String(stderr);
+          annotated.ghArgs = args;
+          reject(annotated);
+        } else {
+          resolve17(stdout.trimEnd());
+        }
+      }
+    );
+  });
+}
+
+// ../../packages/runtime/src/git/mention-refs.ts
+var REF_SCAN_LIMIT = 500;
+var COMMIT_SCAN_LIMIT = 500;
+var REF_FORMAT = ["%(refname:short)", "%(objectname)", "%(subject)", "%(committerdate:iso-strict)", "%(HEAD)"].join("%00");
+var TAG_FORMAT = ["%(refname:short)", "%(objectname)", "%(subject)", "%(creatordate:iso-strict)"].join("%00");
+var LOG_FORMAT = ["%H", "%s", "%an", "%aI"].join("%x00");
+var HEX_PREFIX_RE = /^[0-9a-f]{4,40}$/i;
+var ISSUE_NUMBER_RE = /^#?(\d+)$/;
+var GH_ITEM_FIELDS = "number,title,state,author,updatedAt";
+var GH_PR_FIELDS = `${GH_ITEM_FIELDS},isDraft`;
+async function listGitMentionRefs(kind, query, runners, limit = GIT_MENTION_REF_LIMIT) {
+  const { git: git2, gh } = typeof runners === "function" ? { git: runners } : runners;
+  const needle = query.trim();
+  if (isGitHubRefKind(kind)) {
+    if (!gh) return { ok: false, reason: "gh-unavailable" };
+    try {
+      return { ok: true, refs: (await listGitHubItems(kind, needle, gh)).slice(0, limit) };
+    } catch (err) {
+      if (isGhMissingError(err)) return { ok: false, reason: "gh-unavailable" };
+      return { ok: false, reason: "error", error: ghErrorMessage(err) };
+    }
+  }
+  try {
+    const refs = await listRefs(kind, needle, git2);
+    return { ok: true, refs: refs.slice(0, limit) };
+  } catch (err) {
+    if (isNotGitRepoError(err)) return { ok: false, reason: "not-repo" };
+    return { ok: false, reason: "error", error: err.message };
+  }
+}
+async function probeGitMentionCapabilities(runners) {
+  let repo = "ready";
+  try {
+    await runners.git(["rev-parse", "--git-dir"]);
+  } catch {
+    repo = "not-repo";
+  }
+  if (repo !== "ready" || !runners.gh) return { repo, github: false };
+  try {
+    await runners.gh(["repo", "view", "--json", "nameWithOwner"]);
+    return { repo, github: true };
+  } catch {
+    return { repo, github: false };
+  }
+}
+function ghErrorMessage(err) {
+  const e = err;
+  const stderr = e.stderr?.trim();
+  return stderr ? stderr.split("\n")[0] : e.message ?? "gh failed";
+}
+async function listRefs(kind, needle, run) {
+  switch (kind) {
+    case "branch":
+      return listBranches(needle, run);
+    case "tag":
+      return listTags(needle, run);
+    case "commit":
+      return listCommits(needle, run);
+    case "worktree":
+      return listWorktrees(needle, run);
+    case "issue":
+    case "pr":
+      throw new Error(`${kind} is a GitHub kind`);
+  }
+}
+function ghItemState(item) {
+  if (item.isDraft) return "draft";
+  const s4 = item.state.toLowerCase();
+  return s4 === "merged" ? "merged" : s4 === "closed" ? "closed" : "open";
+}
+function parseGhItems(kind, raw) {
+  const items = JSON.parse(raw || "[]");
+  return (Array.isArray(items) ? items : [items]).map((item) => ({
+    kind,
+    id: String(item.number),
+    label: `#${item.number}`,
+    detail: item.title ?? "",
+    date: item.updatedAt,
+    author: item.author?.login,
+    state: ghItemState(item),
+    host: "github"
+  }));
+}
+async function listGitHubItems(kind, needle, gh) {
+  const fields = kind === "pr" ? GH_PR_FIELDS : GH_ITEM_FIELDS;
+  const list = (extra) => gh([kind, "list", "--limit", String(GIT_MENTION_REF_LIMIT), "--json", fields, ...extra]);
+  if (!needle) return parseGhItems(kind, await list(["--state", "open"]));
+  const searched = parseGhItems(kind, await list(["--state", "all", "--search", needle]));
+  const number4 = ISSUE_NUMBER_RE.exec(needle)?.[1];
+  if (!number4) return searched;
+  let exact = [];
+  try {
+    exact = parseGhItems(kind, await gh([kind, "view", number4, "--json", fields]));
+  } catch {
+  }
+  const seen = new Set(exact.map((r) => r.id));
+  return [...exact, ...searched.filter((r) => !seen.has(r.id))];
+}
+async function listBranches(needle, run) {
+  const raw = await run([
+    "for-each-ref",
+    "refs/heads",
+    "--sort=-committerdate",
+    `--count=${REF_SCAN_LIMIT}`,
+    `--format=${REF_FORMAT}`
+  ]);
+  const refs = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    const [name = "", , subject = "", date5 = "", head = ""] = line.split("\0");
+    const ref = { kind: "branch", id: name, label: name, detail: subject, date: date5, current: head === "*" };
+    if (gitRefMatches(ref, needle)) refs.push(ref);
+  }
+  refs.sort((a, b3) => Number(b3.current === true) - Number(a.current === true));
+  return refs;
+}
+async function listTags(needle, run) {
+  const raw = await run([
+    "for-each-ref",
+    "refs/tags",
+    "--sort=-creatordate",
+    `--count=${REF_SCAN_LIMIT}`,
+    `--format=${TAG_FORMAT}`
+  ]);
+  const refs = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    const [name = "", , subject = "", date5 = ""] = line.split("\0");
+    const ref = { kind: "tag", id: name, label: name, detail: subject, date: date5 };
+    if (gitRefMatches(ref, needle)) refs.push(ref);
+  }
+  return refs;
+}
+function parseLog(raw) {
+  const refs = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    const [sha = "", subject = "", author = "", date5 = ""] = line.split("\0");
+    if (!sha) continue;
+    refs.push({ kind: "commit", id: sha, label: sha.slice(0, 7), detail: subject, date: date5, author });
+  }
+  return refs;
+}
+async function listCommits(needle, run) {
+  if (!needle) return parseLog(await run(["log", `-n${GIT_MENTION_REF_LIMIT}`, `--format=${LOG_FORMAT}`]));
+  const recent = parseLog(await run(["log", `-n${COMMIT_SCAN_LIMIT}`, `--format=${LOG_FORMAT}`]));
+  const byMessage = recent.filter((r) => gitRefMatches(r, needle)).slice(0, GIT_MENTION_REF_LIMIT);
+  if (!HEX_PREFIX_RE.test(needle)) return byMessage;
+  let bySha = [];
+  try {
+    bySha = parseLog(await run(["log", "-n1", `--format=${LOG_FORMAT}`, needle, "--"]));
+  } catch {
+  }
+  const seen = new Set(bySha.map((r) => r.id));
+  return [...bySha, ...byMessage.filter((r) => !seen.has(r.id))];
+}
+async function listWorktrees(needle, run) {
+  const [raw, toplevel] = await Promise.all([
+    run(["worktree", "list", "--porcelain"]),
+    run(["rev-parse", "--show-toplevel"]).catch(() => "")
+  ]);
+  const here = toplevel.trim().replace(/[\\/]+$/, "");
+  const refs = [];
+  for (const wt2 of parseWorktreePorcelain(raw)) {
+    if (wt2.bare) continue;
+    const label = wt2.branch ?? (wt2.head ? `detached @ ${wt2.head.slice(0, 7)}` : wt2.path);
+    const ref = {
+      kind: "worktree",
+      id: wt2.path,
+      label,
+      detail: wt2.path,
+      current: !!here && wt2.path.replace(/[\\/]+$/, "") === here
+    };
+    if (gitRefMatches(ref, needle)) refs.push(ref);
+  }
+  refs.sort((a, b3) => Number(b3.current === true) - Number(a.current === true));
+  return refs;
+}
+
 // ../../packages/runtime/src/git/worktree-plan.ts
 import { basename as basename3, dirname as dirname17, join as join32, resolve as resolve12, sep as sep4 } from "node:path";
 import { homedir as homedir8 } from "node:os";
@@ -86074,6 +86449,7 @@ function parseNumstat(numstat) {
 }
 
 // src/workspace/git-service.ts
+var GH_TIMEOUT_MS = 15e3;
 function git(cwd, args, env) {
   return gitRunSync(cwd, args, env);
 }
@@ -86216,6 +86592,21 @@ var WorkspaceGitService = class {
       return { ok: false, error: gitErrorMessage(err) };
     }
   }
+  /** `@git` / `@gh` popup rows; `absolutePath` narrows to a linked worktree of the project. */
+  mentionRefs(projectId, kind, query, absolutePath) {
+    return listGitMentionRefs(kind, query, this.mentionRunners(projectId, absolutePath));
+  }
+  /** What the `@git` / `@gh` portals may offer for the project (or one of its worktrees). */
+  mentionCapabilities(projectId, absolutePath) {
+    return probeGitMentionCapabilities(this.mentionRunners(projectId, absolutePath));
+  }
+  mentionRunners(projectId, absolutePath) {
+    const cwd = absolutePath ? this.assertRepoWorktreePath(projectId, absolutePath) : this.root(projectId);
+    return {
+      git: async (args) => gitRunSync(cwd, args),
+      gh: (args) => ghRun(cwd, args, GH_TIMEOUT_MS)
+    };
+  }
   worktrees(projectId) {
     const cwd = this.root(projectId);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@super-one/cli",
-  "version": "0.68.0-alpha",
+  "version": "0.68.0-alpha.1",
   "description": "SuperOne headless node CLI — remote execution environment (RPC, workspaces, sessions).",
   "type": "module",
   "license": "BUSL-1.1",