sanjang 0.3.1 → 0.3.3

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 {};