opencode-skills-deck 0.2.0 → 0.3.1

package/dist/tui.js

@@ -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((resolve2, 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);
+      resolve2(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,67 +19839,78 @@ 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}`));
     });
   });
 }
 
 // packages/core/src/paths.ts
 import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { posix, win32 } from "node:path";
 var APP_DIR = "opencode-skills-deck";
+function pathFor(platform) {
+  return platform === "win32" ? win32 : posix;
+}
+function styleOf(path) {
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\") ? "win32" : "linux";
+}
 function configRootOf(platform, env, home) {
-  return env.XDG_CONFIG_HOME ?? (platform === "win32" ? env.APPDATA ?? join2(home, "AppData", "Roaming") : join2(home, ".config"));
+  const path = pathFor(platform);
+  return env.XDG_CONFIG_HOME ?? (platform === "win32" ? env.APPDATA ?? path.join(home, "AppData", "Roaming") : path.join(home, ".config"));
 }
 function stateRootOf(platform, env, home) {
-  return env.XDG_STATE_HOME ?? (platform === "win32" ? env.LOCALAPPDATA ?? join2(home, "AppData", "Local") : join2(home, ".local", "state"));
+  const path = pathFor(platform);
+  return env.XDG_STATE_HOME ?? (platform === "win32" ? env.LOCALAPPDATA ?? path.join(home, "AppData", "Local") : path.join(home, ".local", "state"));
 }
 function opencodeConfigDir(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const home = options.home ?? homedir();
-  return join2(configRootOf(platform, env, home), "opencode");
+  return pathFor(platform).join(configRootOf(platform, env, home), "opencode");
 }
 function opencodeSkillsDir(options = {}) {
-  return join2(opencodeConfigDir(options), "skills");
+  return pathFor(options.platform ?? process.platform).join(opencodeConfigDir(options), "skills");
 }
 function repoSessionSlug(repo) {
   return repo.replace(/[^a-zA-Z0-9._-]+/g, "__");
 }
 function sessionsDirFor(paths, repo) {
-  return repo ? join2(paths.sessionsDir, repoSessionSlug(repo)) : paths.sessionsDir;
+  if (!repo) return paths.sessionsDir;
+  return pathFor(styleOf(paths.sessionsDir)).join(paths.sessionsDir, repoSessionSlug(repo));
 }
 function resolvePaths(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const home = options.home ?? homedir();
+  const path = pathFor(platform);
   const configRoot = configRootOf(platform, env, home);
   const stateRoot = stateRootOf(platform, env, home);
-  const configDir = join2(configRoot, APP_DIR);
-  const stateDir = join2(stateRoot, APP_DIR);
+  const configDir = path.join(configRoot, APP_DIR);
+  const stateDir = path.join(stateRoot, APP_DIR);
   return {
     configDir,
     stateDir,
-    sessionsDir: join2(stateDir, "sessions"),
-    issueCacheDir: join2(stateDir, "issues")
+    sessionsDir: path.join(stateDir, "sessions"),
+    issueCacheDir: path.join(stateDir, "issues")
   };
 }
 
 // packages/core/src/repo.ts
 import { execFileSync } from "node:child_process";
-import { join as join3 } from "node:path";
+import { join as join2, posix as posix2, win32 as win322 } from "node:path";
 var REMOTE_PATTERNS = [
   /^git@[^:]+:(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?$/,
   /^(?:ssh|git|https?):\/\/(?:[^@/]+@)?[^/]+\/(?<owner>[^/]+)\/(?<name>[^/]+?)(?:\.git)?\/?$/
@@ -19904,7 +19935,7 @@ function branchName(issueNumber, title) {
   return slug ? `issue/${issueNumber}-${slug}` : `issue/${issueNumber}`;
 }
 function issueWorktreePath(repoRoot, issueNumber) {
-  return join3(repoRoot, ".worktrees", `issue-${issueNumber}`);
+  return join2(repoRoot, ".worktrees", `issue-${issueNumber}`);
 }
 function issueKey(issueNumber) {
   return `issue-${issueNumber}`;
@@ -19960,10 +19991,10 @@ import {
   watch,
   writeFileSync
 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join3 } from "node:path";
 var STARTUP_GRACE_MS = 2e4;
 function sessionFilePath(dir, key) {
-  return join4(dir, `${key}.json`);
+  return join3(dir, `${key}.json`);
 }
 function readSessions(dir) {
   if (!existsSync(dir)) return [];
@@ -20090,7 +20121,7 @@ function migrateLegacySessions(input2) {
 // packages/core/src/terminal.ts
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join4 } from "node:path";
 var DARWIN_BINARIES = {
   alacritty: "/Applications/Alacritty.app/Contents/MacOS/alacritty",
   kitty: "/Applications/kitty.app/Contents/MacOS/kitty"
@@ -20099,7 +20130,7 @@ function whichInPath(command, env) {
   const pathValue = env.PATH ?? "";
   for (const directory of pathValue.split(delimiter)) {
     if (!directory) continue;
-    const candidate = join5(directory, command);
+    const candidate = join4(directory, command);
     if (existsSync2(candidate)) return candidate;
   }
   return null;
@@ -20174,8 +20205,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 join5, resolve, sep } from "node:path";
 async function defaultBranch(input2) {
   if (input2.configured) return input2.configured;
   try {
@@ -20192,22 +20223,54 @@ async function ensureWorktreesExcluded(input2) {
   const { stdout } = await input2.runner("git", ["rev-parse", "--git-path", "info/exclude"], {
     cwd: input2.repoRoot
   });
-  const path = join6(input2.repoRoot, stdout.trim());
+  const path = join5(input2.repoRoot, stdout.trim());
   const existing = existsSync3(path) ? readFileSync3(path, "utf8") : "";
   if (existing.split("\n").some((line) => line.trim() === ".worktrees/")) return;
   const suffix = existing.endsWith("\n") || existing === "" ? "" : "\n";
   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 resolve(path).replace(/\/+$/, "");
+  }
 }
 async function findOrphanWorktrees(input2) {
-  const root = normalized(join6(input2.repoRoot, ".worktrees"));
+  const root = normalized(join5(input2.repoRoot, ".worktrees"));
   const known = new Set(
     input2.records.map((record2) => record2.worktree).filter((value) => Boolean(value)).map(normalized)
   );
@@ -20372,8 +20435,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, join as join6 } from "node:path";
 var SUMMARY_HEADING = /summary|要約|概要/i;
 var CRITERIA_HEADING = /acceptance criteria|受け入れ基準|完了条件|acceptance/i;
 var BULLET = /^\s*(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s*)?(.+)$/;
@@ -20431,42 +20494,103 @@ async function fetchIssues(input2) {
   return rows.map(toIssue).sort((left, right) => left.number - right.number);
 }
 function issueCachePath(paths, repo) {
-  return join7(paths.issueCacheDir, `${repo.owner}__${repo.name}.json`);
+  return join6(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));
+  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 { join as join8, relative, sep as sep2 } from "node:path";
+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 join7, relative, sep as sep2 } from "node:path";
 var MANIFEST_NAME = ".skills-deck.json";
 function hashSkillDir(dir) {
   const hash2 = createHash("sha256");
@@ -20475,7 +20599,7 @@ function hashSkillDir(dir) {
       (left, right) => left.name.localeCompare(right.name)
     );
     for (const entry of entries) {
-      const absolute = join8(current, entry.name);
+      const absolute = join7(current, entry.name);
       const key = relative(dir, absolute).split(sep2).join("/");
       if (entry.isDirectory()) {
         hash2.update(`d:${key}
@@ -20494,7 +20618,7 @@ function hashSkillDir(dir) {
 }
 function readManifest(targetDir) {
   try {
-    const parsed = JSON.parse(readFileSync5(join8(targetDir, MANIFEST_NAME), "utf8"));
+    const parsed = JSON.parse(readFileSync5(join7(targetDir, MANIFEST_NAME), "utf8"));
     if (!parsed || typeof parsed.version !== "string" || typeof parsed.skills !== "object") return null;
     return parsed;
   } catch {
@@ -20502,19 +20626,19 @@ function readManifest(targetDir) {
   }
 }
 function writeManifest(targetDir, manifest) {
-  writeFileSync4(join8(targetDir, MANIFEST_NAME), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync4(join7(targetDir, MANIFEST_NAME), `${JSON.stringify(manifest, null, 2)}
 `);
 }
 function readBundledVersion(sourceDir) {
   try {
-    return readFileSync5(join8(sourceDir, "VERSION"), "utf8").trim() || "unknown";
+    return readFileSync5(join7(sourceDir, "VERSION"), "utf8").trim() || "unknown";
   } catch {
     return "unknown";
   }
 }
 function skillNames(sourceDir) {
   if (!existsSync4(sourceDir)) return [];
-  return readdirSync2(sourceDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => existsSync4(join8(sourceDir, name, "SKILL.md"))).sort();
+  return readdirSync2(sourceDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => existsSync4(join7(sourceDir, name, "SKILL.md"))).sort();
 }
 function installBundledSkills(input2) {
   const result = { installed: [], updated: [], skipped: [], unchanged: [] };
@@ -20524,8 +20648,8 @@ function installBundledSkills(input2) {
   const manifest = readManifest(input2.targetDir) ?? { version: version2, skills: {} };
   const now = new Date(input2.now ?? Date.now()).toISOString();
   for (const name of skillNames(input2.sourceDir)) {
-    const source = join8(input2.sourceDir, name);
-    const target = join8(input2.targetDir, name);
+    const source = join7(input2.sourceDir, name);
+    const target = join7(input2.targetDir, name);
     const sourceHash = hashSkillDir(source);
     if (!existsSync4(target)) {
       cpSync(source, target, { recursive: true });
@@ -20552,7 +20676,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);