sanjang 0.3.0 → 0.3.2

package/lib/engine/smart-pr.ts

@@ -1,130 +0,0 @@
-/**
- * Smart PR description generator.
- *
- * Uses `claude -p` to generate a human-readable PR description from the diff.
- * Falls back to a simple file-count summary when the CLI is unavailable.
- */
-
-import { spawn, spawnSync } from "node:child_process";
-
-const TIMEOUT_MS = 30_000;
-
-interface SpawnResult {
-  stdout: string;
-  stderr: string;
-  code: number | null;
-  timedOut: boolean;
-}
-
-/**
- * Run a command asynchronously with a timeout.
- */
-function run(cmd: string, args: string[], opts: { cwd: string; timeoutMs: number }): Promise<SpawnResult> {
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-
-    const child = spawn(cmd, args, {
-      cwd: opts.cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, FORCE_COLOR: "0" },
-    });
-
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-    }, opts.timeoutMs);
-
-    child.stdout.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
-    });
-
-    child.on("close", (code: number | null) => {
-      clearTimeout(timer);
-      resolve({ stdout, stderr, code, timedOut });
-    });
-
-    child.on("error", () => {
-      clearTimeout(timer);
-      resolve({ stdout, stderr, code: null, timedOut });
-    });
-  });
-}
-
-/**
- * Parse diff --stat output to extract file count.
- * Example line: " 3 files changed, 10 insertions(+), 2 deletions(-)"
- */
-export function parseDiffStatSummary(diffStat: string): string {
-  const trimmed = diffStat.trim();
-  if (!trimmed) return "변경사항이 없어요";
-
-  const lines = trimmed.split("\n");
-  const summaryLine = lines[lines.length - 1] ?? "";
-  const filesMatch = /(\d+)\s+files?\s+changed/.exec(summaryLine);
-  const insertMatch = /(\d+)\s+insertions?/.exec(summaryLine);
-  const deleteMatch = /(\d+)\s+deletions?/.exec(summaryLine);
-
-  const fileCount = filesMatch ? parseInt(filesMatch[1]!, 10) : 0;
-  const insertions = insertMatch ? parseInt(insertMatch[1]!, 10) : 0;
-  const deletions = deleteMatch ? parseInt(deleteMatch[1]!, 10) : 0;
-
-  if (fileCount === 0) return "변경사항이 없어요";
-
-  const parts: string[] = [`${fileCount}개 파일을 수정했어요`];
-  if (insertions > 0 || deletions > 0) {
-    parts.push(`(+${insertions}, -${deletions})`);
-  }
-  return parts.join(" ");
-}
-
-/**
- * Check if claude CLI is available on PATH.
- */
-function isClaudeAvailable(): boolean {
-  const result = spawnSync("which", ["claude"], { stdio: "pipe" });
-  return result.status === 0;
-}
-
-/**
- * Generate a PR description for the given worktree path.
- *
- * 1. Runs `git diff --stat` and `git diff` in the worktree.
- * 2. If claude CLI is available, asks it to summarise in Korean.
- * 3. Falls back to a simple file-count summary otherwise.
- */
-export async function generatePrDescription(wtPath: string): Promise<string> {
-  // Gather diff info
-  const [statResult, diffResult] = await Promise.all([
-    run("git", ["diff", "--stat", "HEAD"], { cwd: wtPath, timeoutMs: 10_000 }),
-    run("git", ["diff", "HEAD"], { cwd: wtPath, timeoutMs: 10_000 }),
-  ]);
-
-  const diffStat = statResult.stdout.trim();
-  const diff = diffResult.stdout;
-
-  if (!diffStat && !diff.trim()) {
-    return "변경사항이 없어요";
-  }
-
-  // Try claude CLI
-  if (isClaudeAvailable()) {
-    const diffSnippet = diff.slice(0, 500);
-    const prompt = `이 변경사항을 비개발자도 이해할 수 있게 한국어 2-3줄로 설명해줘:\n\n${diffStat}\n\n${diffSnippet}`;
-    const claudeResult = await run("claude", ["-p", prompt, "--output-format", "text"], {
-      cwd: wtPath,
-      timeoutMs: TIMEOUT_MS,
-    });
-
-    if (claudeResult.code === 0 && claudeResult.stdout.trim()) {
-      return claudeResult.stdout.trim();
-    }
-  }
-
-  // Fallback
-  return parseDiffStatSummary(diffStat);
-}

package/lib/engine/snapshot.ts

@@ -1,45 +0,0 @@
-import { simpleGit } from "simple-git";
-import { campPath } from "./worktree.ts";
-
-const STASH_PREFIX = "sanjang-snapshot:";
-
-interface StashEntry {
-  index: number;
-  message: string;
-  isSanjangSnapshot: boolean;
-  date: string;
-}
-
-export async function saveSnapshot(name: string, label: string): Promise<void> {
-  const git = simpleGit(campPath(name));
-  await git.raw(["stash", "push", "--include-untracked", "-m", `${STASH_PREFIX}${label}`]);
-}
-
-export async function restoreSnapshot(name: string, index: number): Promise<void> {
-  const git = simpleGit(campPath(name));
-  await git.raw(["checkout", "--", "."]).catch(() => {});
-  await git.raw(["clean", "-fd"]).catch(() => {});
-  await git.raw(["stash", "apply", `stash@{${index}}`]);
-}
-
-export async function listSnapshots(name: string): Promise<StashEntry[]> {
-  const git = simpleGit(campPath(name));
-  try {
-    const result = await git.raw(["stash", "list", "--format=%gd|%s|%ci"]);
-    if (!result?.trim()) return [];
-
-    return result
-      .trim()
-      .split("\n")
-      .map((line: string) => {
-        const [ref, message, date] = line.split("|");
-        const match = ref?.match(/stash@\{(\d+)\}/);
-        const index = match ? parseInt(match[1]!, 10) : 0;
-        const isSanjangSnapshot = message ? message.includes(STASH_PREFIX) : false;
-        return { index, message: message || "", isSanjangSnapshot, date: date || "" };
-      })
-      .filter((entry: StashEntry) => entry.isSanjangSnapshot);
-  } catch {
-    return [];
-  }
-}

package/lib/engine/state.ts

@@ -1,60 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { Camp } from "../types.ts";
-
-let campsDir: string | null = null;
-
-export function setCampsDir(dir: string): void {
-  campsDir = dir;
-}
-
-export function getCampsDir(): string {
-  if (!campsDir) throw new Error("campsDir not initialized. Call setCampsDir() first.");
-  return campsDir;
-}
-
-function stateFile(): string {
-  return join(getCampsDir(), "state.json");
-}
-
-function ensureDir(): void {
-  mkdirSync(getCampsDir(), { recursive: true });
-}
-
-function read(): Camp[] {
-  const f = stateFile();
-  if (!existsSync(f)) return [];
-  try {
-    return JSON.parse(readFileSync(f, "utf8"));
-  } catch {
-    return [];
-  }
-}
-
-function write(records: Camp[]): void {
-  ensureDir();
-  // Atomic write: write to temp file then rename to prevent corruption
-  const tmp = stateFile() + ".tmp";
-  writeFileSync(tmp, JSON.stringify(records, null, 2), "utf8");
-  renameSync(tmp, stateFile());
-}
-
-export function getAll(): Camp[] {
-  return read();
-}
-
-export function getOne(name: string): Camp | null {
-  return read().find((r) => r.name === name) ?? null;
-}
-
-export function upsert(record: Camp): void {
-  const records = read();
-  const idx = records.findIndex((r) => r.name === record.name);
-  if (idx === -1) records.push(record);
-  else records[idx] = record;
-  write(records);
-}
-
-export function remove(name: string): void {
-  write(read().filter((r) => r.name !== name));
-}

package/lib/engine/suggest.ts

@@ -1,169 +0,0 @@
-/**
- * Task suggestion engine.
- *
- * Aggregates open issues, PRs, and recent git activity to surface
- * actionable suggestions on the dashboard — no LLM required.
- */
-
-import { spawn } from "node:child_process";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface Suggestion {
-  type: "issue" | "pr" | "recent";
-  title: string;
-  detail?: string;
-  action?: string; // e.g., branch name to create camp from
-}
-
-interface GhIssue {
-  number: number;
-  title: string;
-  labels: Array<{ name: string }>;
-}
-
-interface GhPr {
-  number: number;
-  title: string;
-  headRefName: string;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const TIMEOUT_MS = 10_000;
-
-/**
- * Async spawn wrapper — resolves with stdout or rejects on timeout / error.
- */
-function run(cmd: string, args: string[], cwd: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env },
-    });
-
-    let stdout = "";
-    let stderr = "";
-
-    child.stdout.on("data", (chunk: Buffer) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk: Buffer) => {
-      stderr += chunk.toString();
-    });
-
-    const timer = setTimeout(() => {
-      child.kill("SIGTERM");
-      reject(new Error(`Command timed out: ${cmd} ${args.join(" ")}`));
-    }, TIMEOUT_MS);
-
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (code === 0) resolve(stdout);
-      else reject(new Error(`Exit ${code}: ${stderr || stdout}`));
-    });
-
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Data fetchers
-// ---------------------------------------------------------------------------
-
-async function fetchIssues(cwd: string): Promise<Suggestion[]> {
-  const raw = await run(
-    "gh",
-    ["issue", "list", "--state", "open", "--limit", "5", "--json", "number,title,labels"],
-    cwd,
-  );
-  const issues: GhIssue[] = JSON.parse(raw);
-  return issues.map((i) => {
-    const labelStr = i.labels.map((l) => l.name).join(", ");
-    return {
-      type: "issue" as const,
-      title: `#${i.number} ${i.title}`,
-      detail: labelStr || undefined,
-    };
-  });
-}
-
-async function fetchMyPrs(cwd: string): Promise<Suggestion[]> {
-  const raw = await run(
-    "gh",
-    ["pr", "list", "--state", "open", "--author", "@me", "--limit", "3", "--json", "number,title,headRefName"],
-    cwd,
-  );
-  const prs: GhPr[] = JSON.parse(raw);
-  return prs.map((p) => ({
-    type: "pr" as const,
-    title: `#${p.number} ${p.title}`,
-    detail: p.headRefName,
-    action: p.headRefName,
-  }));
-}
-
-async function fetchRecentCommits(cwd: string): Promise<Suggestion[]> {
-  const raw = await run("git", ["log", "--oneline", "-10"], cwd);
-  const lines = raw.trim().split("\n").filter(Boolean);
-  return lines.map((line) => {
-    const spaceIdx = line.indexOf(" ");
-    const hash = spaceIdx > 0 ? line.slice(0, spaceIdx) : line;
-    const msg = spaceIdx > 0 ? line.slice(spaceIdx + 1) : "";
-    return {
-      type: "recent" as const,
-      title: msg || hash,
-      detail: hash,
-    };
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-/**
- * Suggest tasks the user might work on next.
- *
- * Aggregates data from GitHub (issues, PRs) and git (recent commits).
- * If `gh` CLI is unavailable, returns git-based suggestions only.
- *
- * Results are sorted by relevance: PRs (이어하기) > Issues (이슈) > Recent (최근 작업).
- */
-export async function suggestTasks(projectRoot: string): Promise<Suggestion[]> {
-  const results: Suggestion[] = [];
-
-  // gh-dependent fetches — tolerate failure (gh not installed / no repo)
-  const [issues, prs] = await Promise.allSettled([
-    fetchIssues(projectRoot),
-    fetchMyPrs(projectRoot),
-  ]);
-
-  // PRs first — most actionable ("이어하기")
-  if (prs.status === "fulfilled") {
-    results.push(...prs.value);
-  }
-
-  // Issues next ("이슈")
-  if (issues.status === "fulfilled") {
-    results.push(...issues.value);
-  }
-
-  // Recent commits always available ("최근 작업")
-  try {
-    const recent = await fetchRecentCommits(projectRoot);
-    results.push(...recent);
-  } catch {
-    // No git history — return whatever we have
-  }
-
-  return results;
-}

package/lib/engine/warp.ts

@@ -1,47 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-
-interface WarpDetectResult {
-  installed: boolean;
-}
-
-interface WarpOpenResult {
-  opened: boolean;
-  terminal: string | null;
-  path?: string;
-}
-
-/**
- * Detect if Warp terminal is installed.
- */
-export function detectWarp(): WarpDetectResult {
-  const installed = existsSync("/Applications/Warp.app");
-  return { installed };
-}
-
-/**
- * Open a Warp tab at the given worktree path.
- * Opens as a new tab in the existing Warp window (not a new window).
- * The tab title naturally shows the directory name (= camp name).
- */
-export function openWarpTab(campName: string, worktreePath: string): WarpOpenResult {
-  const { installed } = detectWarp();
-  if (!installed) {
-    return { opened: false, terminal: null, path: worktreePath };
-  }
-
-  // open -a Warp {path} → opens tab in existing window with dir name as title
-  const result = spawnSync("open", ["-a", "Warp", worktreePath], { stdio: "pipe" });
-
-  return {
-    opened: result.status === 0,
-    terminal: "warp",
-  };
-}
-
-/**
- * No-op cleanup (launch config removed — using open -a instead).
- */
-export function removeLaunchConfig(_campName: string): void {
-  // Intentionally empty — kept for API compatibility with server.ts
-}

package/lib/engine/watcher.ts

@@ -1,40 +0,0 @@
-import { watch, type FSWatcher } from "node:fs";
-
-export class CampWatcher {
-  private watcher: FSWatcher | null = null;
-  private timer: ReturnType<typeof setTimeout> | null = null;
-  private stopped = false;
-
-  constructor(
-    private readonly dir: string,
-    private readonly onChange: () => void,
-    private readonly debounceMs: number = 500,
-  ) {}
-
-  start(): void {
-    this.stopped = false;
-    try {
-      this.watcher = watch(this.dir, { recursive: true }, () => {
-        if (this.stopped) return;
-        if (this.timer) clearTimeout(this.timer);
-        this.timer = setTimeout(() => {
-          if (!this.stopped) this.onChange();
-        }, this.debounceMs);
-      });
-    } catch {
-      // fs.watch can fail on some platforms/dirs — silently degrade
-    }
-  }
-
-  stop(): void {
-    this.stopped = true;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-  }
-}

package/lib/engine/worktree.ts

@@ -1,100 +0,0 @@
-import { join } from "node:path";
-import { type SimpleGit, simpleGit } from "simple-git";
-import { getCampsDir } from "./state.ts";
-
-let projectRoot: string | null = null;
-
-export interface BranchInfo {
-  name: string;
-  remote: boolean;
-  local: boolean;
-  date: string;
-  category?: "default" | "feature" | "fix" | "other";
-}
-
-export function setProjectRoot(root: string): void {
-  projectRoot = root;
-}
-
-export function getProjectRoot(): string {
-  if (!projectRoot) throw new Error("projectRoot not initialized. Call setProjectRoot() first.");
-  return projectRoot;
-}
-
-export function campPath(name: string): string {
-  return join(getCampsDir(), name);
-}
-
-function git(): SimpleGit {
-  return simpleGit(getProjectRoot());
-}
-
-export async function listBranches(): Promise<BranchInfo[]> {
-  // Best-effort fetch — continue with local refs on network failure
-  try {
-    await git().fetch(["--prune"]);
-  } catch {
-    /* offline is OK */
-  }
-
-  const raw = await git().raw([
-    "for-each-ref",
-    "--sort=-committerdate",
-    "--format=%(refname:short)\t%(committerdate:relative)\t%(refname)",
-    "refs/heads/",
-    "refs/remotes/origin/",
-  ]);
-
-  const map = new Map<string, BranchInfo>();
-  for (const line of raw.trim().split("\n")) {
-    if (!line) continue;
-    const [shortName, date, fullRef] = line.split("\t");
-    if (!shortName || !fullRef) continue;
-    if (shortName.includes("HEAD")) continue;
-    const isRemote = fullRef.startsWith("refs/remotes/origin/");
-    const clean = shortName.replace(/^origin\//, "").trim();
-    if (!clean) continue;
-
-    const entry: BranchInfo = map.get(clean) || { name: clean, remote: false, local: false, date: date ?? "" };
-    if (isRemote) entry.remote = true;
-    else entry.local = true;
-    if (!entry.date) entry.date = date ?? "";
-    map.set(clean, entry);
-  }
-
-  const branches = [...map.values()];
-
-  for (const b of branches) {
-    if (["dev", "main", "master"].includes(b.name)) {
-      b.category = "default";
-    } else if (b.name.startsWith("feature/")) {
-      b.category = "feature";
-    } else if (b.name.startsWith("fix/") || b.name.startsWith("hotfix/")) {
-      b.category = "fix";
-    } else {
-      b.category = "other";
-    }
-  }
-
-  return branches;
-}
-
-export async function addWorktree(name: string, branch: string): Promise<void> {
-  const path = campPath(name);
-  const refs = [`origin/${branch}`, branch];
-  let lastErr: unknown;
-  for (const ref of refs) {
-    try {
-      await git().raw(["worktree", "add", "--detach", path, ref]);
-      return;
-    } catch (err) {
-      lastErr = err;
-    }
-  }
-  throw lastErr;
-}
-
-export async function removeWorktree(name: string): Promise<void> {
-  const path = campPath(name);
-  await git().raw(["worktree", "remove", "--force", path]);
-}