opencode-skills-deck 0.2.0-rc.0 → 0.3.0

package/dist/tui.js

@@ -5089,7 +5089,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve2) {
+function isRecursive(inst, stack, resolve3) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -5099,7 +5099,7 @@ function isRecursive(inst, stack, resolve2) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve2);
+      const answer = isRecursive(child, stack, resolve3);
       if (answer > result)
         result = answer;
     }
@@ -5110,7 +5110,7 @@ function isRecursive(inst, stack, resolve2) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve2) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve3) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -5174,7 +5174,7 @@ function isRecursive(inst, stack, resolve2) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve2 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve3 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -19790,16 +19790,36 @@ function normalizeOpenKey(value) {
 // packages/core/src/exec.ts
 import { spawn } from "node:child_process";
 var MAX_BUFFER = 16 * 1024 * 1024;
-function createRunner() {
-  return (command, args, options) => new Promise((resolve2, reject) => {
+var DEFAULT_TIMEOUT_MS = 3e4;
+function createRunner(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return (command, args, options2) => new Promise((resolve3, reject) => {
     const child = spawn(command, args, {
-      cwd: options?.cwd,
+      cwd: options2?.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
     let overflow = false;
+    let settled = false;
+    const fail = (error62) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(error62);
+    };
+    const succeed = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      fail(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
     child.stdout?.setEncoding("utf8");
     child.stderr?.setEncoding("utf8");
     child.stdout?.on("data", (chunk) => {
@@ -19819,19 +19839,20 @@ function createRunner() {
       }
     });
     child.on("error", (error62) => {
-      reject(new Error(`${command} ${args.join(" ")} failed: ${error62.message}`));
+      fail(new Error(`${command} ${args.join(" ")} failed: ${error62.message}`));
     });
     child.on("close", (code) => {
+      if (settled) return;
       if (overflow) {
-        reject(new Error(`${command} ${args.join(" ")} failed: \u51FA\u529B\u304C\u5927\u304D\u3059\u304E\u307E\u3059`));
+        fail(new Error(`${command} ${args.join(" ")} failed: \u51FA\u529B\u304C\u5927\u304D\u3059\u304E\u307E\u3059`));
         return;
       }
       if (code === 0) {
-        resolve2({ stdout, stderr });
+        succeed({ stdout, stderr });
         return;
       }
       const detail = stderr.trim() || `exit code ${code ?? "unknown"}`;
-      reject(new Error(`${command} ${args.join(" ")} failed: ${detail}`));
+      fail(new Error(`${command} ${args.join(" ")} failed: ${detail}`));
     });
   });
 }
@@ -19879,7 +19900,7 @@ function resolvePaths(options = {}) {
 
 // packages/core/src/repo.ts
 import { execFileSync } from "node:child_process";
-import { join as join3 } from "node:path";
+import { dirname, join as join3, resolve } from "node:path";
 var REMOTE_PATTERNS = [
   /^git@[^:]+:(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
   /^(?:ssh|git|https?):\/\/(?:[^@/]+@)?[^/]+\/(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?\/?$/
@@ -20174,8 +20195,8 @@ function launchInTerminal(input2) {
 }
 
 // packages/core/src/worktree.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join6, resolve, sep } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6, resolve as resolve2, sep } from "node:path";
 async function defaultBranch(input2) {
   if (input2.configured) return input2.configured;
   try {
@@ -20199,12 +20220,44 @@ async function ensureWorktreesExcluded(input2) {
   writeFileSync2(path, `${existing}${suffix}.worktrees/
 `);
 }
+async function readWorktreeEntries(input2) {
+  const { stdout } = await input2.runner("git", ["worktree", "list", "--porcelain"], {
+    cwd: input2.repoRoot
+  });
+  const entries = [];
+  let current = null;
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current) entries.push(current);
+      current = {
+        directory: line.slice("worktree ".length).trim(),
+        branch: null,
+        detached: false,
+        bare: false
+      };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "").trim();
+    } else if (line === "detached") {
+      current.detached = true;
+    } else if (line === "bare") {
+      current.bare = true;
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
 async function registeredWorktrees(input2) {
-  const { stdout } = await input2.runner("git", ["worktree", "list", "--porcelain"], { cwd: input2.repoRoot });
-  return stdout.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim());
+  return (await readWorktreeEntries(input2)).map((entry) => entry.directory);
 }
 function normalized(path) {
-  return resolve(path).replace(/\/+$/, "");
+  try {
+    return realpathSync(path).replace(/\/+$/, "");
+  } catch {
+    return resolve2(path).replace(/\/+$/, "");
+  }
 }
 async function findOrphanWorktrees(input2) {
   const root = normalized(join6(input2.repoRoot, ".worktrees"));
@@ -20372,8 +20425,8 @@ function dispatchDialogue(input2) {
 }
 
 // packages/core/src/issue.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname, join as join7 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join7 } from "node:path";
 var SUMMARY_HEADING = /summary|要約|概要/i;
 var CRITERIA_HEADING = /acceptance criteria|受け入れ基準|完了条件|acceptance/i;
 var BULLET = /^\s*(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s*)?(.+)$/;
@@ -20433,39 +20486,100 @@ async function fetchIssues(input2) {
 function issueCachePath(paths, repo) {
   return join7(paths.issueCacheDir, `${repo.owner}__${repo.name}.json`);
 }
+function normalizeCachedIssue(value) {
+  if (!value || typeof value !== "object") return null;
+  const issue2 = value;
+  if (typeof issue2.number !== "number" || typeof issue2.title !== "string") return null;
+  return {
+    number: issue2.number,
+    title: issue2.title,
+    labels: Array.isArray(issue2.labels) ? issue2.labels.filter((label) => typeof label === "string") : [],
+    state: typeof issue2.state === "string" ? issue2.state : "OPEN",
+    updatedAt: typeof issue2.updatedAt === "string" ? issue2.updatedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    summary: typeof issue2.summary === "string" ? issue2.summary : "",
+    criteria: Array.isArray(issue2.criteria) ? issue2.criteria.filter((criterion) => typeof criterion === "string") : []
+  };
+}
 function readIssueCache(path) {
   try {
     const parsed = JSON.parse(readFileSync4(path, "utf8"));
-    return Array.isArray(parsed.issues) ? parsed : null;
+    if (!Array.isArray(parsed.issues) || typeof parsed.fetchedAt !== "number") {
+      rmSync2(path, { force: true });
+      return null;
+    }
+    const issues = parsed.issues.map(normalizeCachedIssue);
+    if (issues.some((issue2) => issue2 === null)) {
+      rmSync2(path, { force: true });
+      return null;
+    }
+    return { fetchedAt: parsed.fetchedAt, issues };
   } catch {
+    try {
+      rmSync2(path, { force: true });
+    } catch {
+    }
     return null;
   }
 }
 function writeIssueCache(path, cache) {
-  mkdirSync2(dirname(path), { recursive: true });
-  writeFileSync3(path, JSON.stringify(cache, null, 2));
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync3(temporary, `${JSON.stringify(cache, null, 2)}
+`);
+  renameSync2(temporary, path);
 }
 var CACHE_TTL_MS = 6e4;
-async function loadIssues(input2) {
+function classifyGhError(error62) {
+  const message = error62 instanceof Error ? error62.message : String(error62);
+  if (/not authenticated|authentication|401|gh auth login/i.test(message)) {
+    return { code: "auth", message };
+  }
+  if (/rate limit|secondary rate|403/i.test(message)) {
+    return { code: "rate_limit", message };
+  }
+  if (/ENOTFOUND|ECONNREFUSED|ETIMEDOUT|fetch failed|network/i.test(message)) {
+    return { code: "network", message };
+  }
+  if (/^gh\b|gh issue/i.test(message)) return { code: "gh", message };
+  return { code: "unknown", message };
+}
+async function loadIssuesResult(input2) {
   const path = issueCachePath(input2.paths, input2.repo);
   const now = input2.now ?? Date.now();
-  if (!input2.force) {
-    const cache = readIssueCache(path);
-    if (cache && now - cache.fetchedAt < CACHE_TTL_MS) return cache.issues;
+  const cache = readIssueCache(path);
+  if (!input2.force && cache && now - cache.fetchedAt < CACHE_TTL_MS) {
+    return { issues: cache.issues, cached: true, stale: false, fetchedAt: cache.fetchedAt, error: null };
   }
-  const issues = await fetchIssues({
-    repo: input2.repo,
-    config: input2.config,
-    runner: input2.runner,
-    cwd: input2.cwd
-  });
-  writeIssueCache(path, { fetchedAt: now, issues });
-  return issues;
+  try {
+    const issues = await fetchIssues({
+      repo: input2.repo,
+      config: input2.config,
+      runner: input2.runner,
+      cwd: input2.cwd
+    });
+    writeIssueCache(path, { fetchedAt: now, issues });
+    return { issues, cached: false, stale: false, fetchedAt: now, error: null };
+  } catch (error62) {
+    const failure2 = classifyGhError(error62);
+    if (cache) {
+      return {
+        issues: cache.issues,
+        cached: true,
+        stale: true,
+        fetchedAt: cache.fetchedAt,
+        error: failure2
+      };
+    }
+    return { issues: [], cached: false, stale: false, fetchedAt: null, error: failure2 };
+  }
+}
+async function loadIssues(input2) {
+  return (await loadIssuesResult(input2)).issues;
 }
 
 // packages/core/src/skills.ts
 import { createHash } from "node:crypto";
-import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { cpSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join8, relative, sep as sep2 } from "node:path";
 var MANIFEST_NAME = ".skills-deck.json";
 function hashSkillDir(dir) {
@@ -20552,7 +20666,7 @@ function installBundledSkills(input2) {
       result.unchanged.push(name);
       continue;
     }
-    rmSync2(target, { recursive: true, force: true });
+    rmSync3(target, { recursive: true, force: true });
     cpSync(source, target, { recursive: true });
     manifest.skills[name] = { hash: sourceHash, updatedAt: now };
     result.updated.push(name);
@@ -21395,7 +21509,7 @@ function ControlTower() {
   async function withDialog(open2) {
     setDialogOpen(true);
     try {
-      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
       return await open2();
     } finally {
       setDialogOpen(false);