sanjang 0.3.0 → 0.3.2

package/dist/lib/engine/state.js

@@ -0,0 +1,53 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+let campsDir = null;
+export function setCampsDir(dir) {
+    campsDir = dir;
+}
+export function getCampsDir() {
+    if (!campsDir)
+        throw new Error("campsDir not initialized. Call setCampsDir() first.");
+    return campsDir;
+}
+function stateFile() {
+    return join(getCampsDir(), "state.json");
+}
+function ensureDir() {
+    mkdirSync(getCampsDir(), { recursive: true });
+}
+function read() {
+    const f = stateFile();
+    if (!existsSync(f))
+        return [];
+    try {
+        return JSON.parse(readFileSync(f, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+function write(records) {
+    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() {
+    return read();
+}
+export function getOne(name) {
+    return read().find((r) => r.name === name) ?? null;
+}
+export function upsert(record) {
+    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) {
+    write(read().filter((r) => r.name !== name));
+}

package/dist/lib/engine/suggest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Task suggestion engine.
+ *
+ * Aggregates open issues, PRs, and recent git activity to surface
+ * actionable suggestions on the dashboard — no LLM required.
+ */
+export interface Suggestion {
+    type: "issue" | "pr" | "recent";
+    title: string;
+    detail?: string;
+    action?: string;
+}
+/**
+ * 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 declare function suggestTasks(projectRoot: string): Promise<Suggestion[]>;

package/dist/lib/engine/suggest.js

@@ -0,0 +1,121 @@
+/**
+ * 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";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const TIMEOUT_MS = 10_000;
+/**
+ * Async spawn wrapper — resolves with stdout or rejects on timeout / error.
+ */
+function run(cmd, args, cwd) {
+    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) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            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) {
+    const raw = await run("gh", ["issue", "list", "--state", "open", "--limit", "5", "--json", "number,title,labels"], cwd);
+    const issues = JSON.parse(raw);
+    return issues.map((i) => {
+        const labelStr = i.labels.map((l) => l.name).join(", ");
+        return {
+            type: "issue",
+            title: `#${i.number} ${i.title}`,
+            detail: labelStr || undefined,
+        };
+    });
+}
+async function fetchMyPrs(cwd) {
+    const raw = await run("gh", ["pr", "list", "--state", "open", "--author", "@me", "--limit", "3", "--json", "number,title,headRefName"], cwd);
+    const prs = JSON.parse(raw);
+    return prs.map((p) => ({
+        type: "pr",
+        title: `#${p.number} ${p.title}`,
+        detail: p.headRefName,
+        action: p.headRefName,
+    }));
+}
+async function fetchRecentCommits(cwd) {
+    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",
+            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) {
+    const results = [];
+    // 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/dist/lib/engine/warp.d.ts

@@ -0,0 +1,23 @@
+interface WarpDetectResult {
+    installed: boolean;
+}
+interface WarpOpenResult {
+    opened: boolean;
+    terminal: string | null;
+    path?: string;
+}
+/**
+ * Detect if Warp terminal is installed.
+ */
+export declare function detectWarp(): WarpDetectResult;
+/**
+ * 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 declare function openWarpTab(campName: string, worktreePath: string): WarpOpenResult;
+/**
+ * No-op cleanup (launch config removed — using open -a instead).
+ */
+export declare function removeLaunchConfig(_campName: string): void;
+export {};

package/dist/lib/engine/warp.js

@@ -0,0 +1,32 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+/**
+ * Detect if Warp terminal is installed.
+ */
+export function detectWarp() {
+    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, worktreePath) {
+    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) {
+    // Intentionally empty — kept for API compatibility with server.ts
+}

package/dist/lib/engine/watcher.d.ts

@@ -0,0 +1,11 @@
+export declare class CampWatcher {
+    private readonly dir;
+    private readonly onChange;
+    private readonly debounceMs;
+    private watcher;
+    private timer;
+    private stopped;
+    constructor(dir: string, onChange: () => void, debounceMs?: number);
+    start(): void;
+    stop(): void;
+}

package/dist/lib/engine/watcher.js

@@ -0,0 +1,43 @@
+import { watch } from "node:fs";
+export class CampWatcher {
+    dir;
+    onChange;
+    debounceMs;
+    watcher = null;
+    timer = null;
+    stopped = false;
+    constructor(dir, onChange, debounceMs = 500) {
+        this.dir = dir;
+        this.onChange = onChange;
+        this.debounceMs = debounceMs;
+    }
+    start() {
+        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() {
+        this.stopped = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+}

package/dist/lib/engine/worktree.d.ts

@@ -0,0 +1,13 @@
+export interface BranchInfo {
+    name: string;
+    remote: boolean;
+    local: boolean;
+    date: string;
+    category?: "default" | "feature" | "fix" | "other";
+}
+export declare function setProjectRoot(root: string): void;
+export declare function getProjectRoot(): string;
+export declare function campPath(name: string): string;
+export declare function listBranches(): Promise<BranchInfo[]>;
+export declare function addWorktree(name: string, branch: string): Promise<void>;
+export declare function removeWorktree(name: string): Promise<void>;

package/dist/lib/engine/worktree.js

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { simpleGit } from "simple-git";
+import { getCampsDir } from "./state.js";
+let projectRoot = null;
+export function setProjectRoot(root) {
+    projectRoot = root;
+}
+export function getProjectRoot() {
+    if (!projectRoot)
+        throw new Error("projectRoot not initialized. Call setProjectRoot() first.");
+    return projectRoot;
+}
+export function campPath(name) {
+    return join(getCampsDir(), name);
+}
+function git() {
+    return simpleGit(getProjectRoot());
+}
+export async function listBranches() {
+    // 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();
+    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 = 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, branch) {
+    const path = campPath(name);
+    const refs = [`origin/${branch}`, branch];
+    let lastErr;
+    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) {
+    const path = campPath(name);
+    await git().raw(["worktree", "remove", "--force", path]);
+}

package/dist/lib/server.d.ts

@@ -0,0 +1,20 @@
+import { type ChildProcess } from "node:child_process";
+import { type Server } from "node:http";
+import express from "express";
+import { CampWatcher } from "./engine/watcher.ts";
+interface CreateAppOptions {
+    port?: number;
+}
+interface CreateAppResult {
+    app: express.Application;
+    server: Server;
+    port: number;
+    runningTasks: Map<string, ChildProcess>;
+    warpStatus: {
+        installed: boolean;
+    };
+    watchers: Map<string, CampWatcher>;
+}
+export declare function createApp(projectRoot: string, options?: CreateAppOptions): Promise<CreateAppResult>;
+export declare function startServer(projectRoot: string, options?: CreateAppOptions): Promise<Server>;
+export {};