sanjang 0.3.0

package/lib/engine/snapshot.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,169 @@
+/**
+ * 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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,100 @@
+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]);
+}