@luuthuong/devboard 0.0.0-stage → 1.0.1

package/server-dist/server/fsBrowse.js

@@ -0,0 +1,143 @@
+// Directory browsing for the in-browser folder picker: listing, quick places
+// and a bounded name search. Directories only; never reads file contents.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const IS_WINDOWS = process.platform === "win32";
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function hasGit(dir) {
+    return fs.promises.access(path.join(dir, ".git")).then(() => true, () => false);
+}
+const PLACE_NAMES = ["Desktop", "Documents", "Downloads", "repos", "source", "code", "dev", "projects", "workspace"];
+function places() {
+    const home = os.homedir();
+    const out = [{ name: "Home", path: home }];
+    const seen = new Set();
+    for (const name of PLACE_NAMES) {
+        const p = path.join(home, name);
+        // Case-insensitive filesystems report "Repos" and "repos" as the same folder.
+        if (seen.has(p.toLowerCase()) || !isDir(p))
+            continue;
+        seen.add(p.toLowerCase());
+        out.push({ name, path: p });
+    }
+    return out;
+}
+function roots() {
+    const list = IS_WINDOWS
+        ? "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            .split("")
+            .map((l) => `${l}:\\`)
+            .filter((r) => fs.existsSync(r))
+        : ["/"];
+    return list.map((r) => ({ name: r, path: r, isDir: true }));
+}
+/** `~`, `~/x` and an empty path resolve against the user's home; anything else is taken as given. */
+function expand(dir) {
+    if (dir === "~")
+        return os.homedir();
+    if (dir.startsWith("~/") || dir.startsWith("~\\"))
+        return path.join(os.homedir(), dir.slice(2));
+    return dir;
+}
+/**
+ * List the subfolders of `dir`. A missing `dir` is the home folder (so the
+ * picker opens where the user works); `""` is the machine's roots (drives).
+ */
+export async function fsList(dir) {
+    const home = os.homedir();
+    if (dir === "")
+        return { path: "", parent: null, home, places: places(), entries: roots() };
+    const resolved = path.resolve(expand(dir || home));
+    const dirents = await fs.promises.readdir(resolved, { withFileTypes: true });
+    const entries = dirents
+        .filter((d) => d.isDirectory() || (d.isSymbolicLink() && isDir(path.join(resolved, d.name))))
+        .map((d) => ({ name: d.name, path: path.join(resolved, d.name), isDir: true }))
+        .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: "base" }));
+    if (entries.length <= 400) {
+        await Promise.all(entries.map(async (e) => {
+            if (await hasGit(e.path))
+                e.isRepo = true;
+        }));
+    }
+    const parent = path.dirname(resolved);
+    return { path: resolved, parent: parent === resolved ? "" : parent, home, places: places(), entries };
+}
+const SKIP = new Set([
+    "node_modules",
+    "appdata",
+    "library",
+    "target",
+    "dist",
+    "build",
+    "venv",
+    "__pycache__",
+    "vendor",
+    "windows",
+    "program files",
+    "program files (x86)",
+    "programdata",
+    "$recycle.bin",
+    "system volume information",
+]);
+/**
+ * Find folders under `root` (default: home) whose name contains every word of
+ * `query`. Breadth-first, so shallow matches win, and bounded by depth, folder
+ * count and time so a huge disk can't stall the server.
+ */
+export async function fsSearch(query, root) {
+    const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return [];
+    const start = path.resolve(expand(root || os.homedir()));
+    const deadline = Date.now() + 1500;
+    const MAX_VISITED = 8000;
+    const MAX_DEPTH = 5;
+    const hits = [];
+    let level = [start];
+    let visited = 0;
+    for (let depth = 0; depth <= MAX_DEPTH && level.length > 0; depth++) {
+        const next = [];
+        // Read one level in small parallel batches, checking the clock between them.
+        for (let i = 0; i < level.length; i += 24) {
+            if (Date.now() > deadline || visited > MAX_VISITED)
+                break;
+            const batch = level.slice(i, i + 24);
+            const results = await Promise.all(batch.map((d) => fs.promises.readdir(d, { withFileTypes: true }).catch(() => [])));
+            results.forEach((dirents, j) => {
+                for (const d of dirents) {
+                    if (!d.isDirectory())
+                        continue;
+                    const lower = d.name.toLowerCase();
+                    if (d.name.startsWith(".") || SKIP.has(lower))
+                        continue;
+                    visited++;
+                    const full = path.join(batch[j], d.name);
+                    if (tokens.every((t) => lower.includes(t))) {
+                        const score = (lower === tokens.join(" ") ? 0 : lower.startsWith(tokens[0]) ? 1 : 2) + depth * 0.25;
+                        hits.push({ name: d.name, path: full, parent: batch[j], isRepo: false, score });
+                    }
+                    next.push(full);
+                }
+            });
+        }
+        if (hits.length >= 60 || Date.now() > deadline || visited > MAX_VISITED)
+            break;
+        level = next;
+    }
+    hits.sort((a, b) => a.score - b.score || a.name.localeCompare(b.name));
+    const top = hits.slice(0, 30);
+    await Promise.all(top.map(async (h) => {
+        h.isRepo = await hasGit(h.path);
+    }));
+    // Project roots first within the same relevance band.
+    top.sort((a, b) => Math.floor(a.score) - Math.floor(b.score) || Number(b.isRepo) - Number(a.isRepo) || a.score - b.score);
+    return top.map(({ score: _score, ...h }) => h);
+}

package/server-dist/server/git.js

@@ -0,0 +1,258 @@
+// Git + GitHub CLI adapters. Ports git_worktree.rs, git_remote.rs and gh_cli.rs.
+import path from "node:path";
+import { findOnPath, IS_WINDOWS, run } from "./util.js";
+import { isWsl } from "./sessions.js";
+export async function createWorktree(repoRoot, name) {
+    const wtPath = path.join(repoRoot, ".worktrees", name);
+    const r = await run("git", ["worktree", "add", "-b", name, wtPath], { cwd: repoRoot });
+    if (!r.ok)
+        throw new Error(`git worktree add failed: ${r.stderr}`);
+    return { path: wtPath, branch: name, isMain: false };
+}
+/** `repoRoot` omitted → derive it from the worktree path. */
+export async function removeWorktree(wtPath, repoRoot, force) {
+    const args = ["worktree", "remove"];
+    if (force)
+        args.push("--force");
+    args.push(wtPath);
+    let root = repoRoot;
+    if (!root) {
+        const idx = [wtPath.indexOf("\\.worktrees\\"), wtPath.indexOf("/.worktrees/")].find((i) => i >= 0);
+        root = idx !== undefined ? wtPath.slice(0, idx) : path.dirname(wtPath) || ".";
+    }
+    const r = await run("git", args, { cwd: root });
+    if (!r.ok)
+        throw new Error(`git worktree remove failed: ${r.stderr}`);
+}
+export async function listWorktrees(repoRoot) {
+    const r = await run("git", ["worktree", "list", "--porcelain"], { cwd: repoRoot });
+    if (!r.ok)
+        return [];
+    const out = [];
+    let curPath;
+    let curBranch;
+    let first = true;
+    for (const line of r.stdout.split(/\r?\n/)) {
+        if (line.startsWith("worktree ")) {
+            if (curPath !== undefined) {
+                out.push({ path: curPath, branch: curBranch, isMain: first });
+                first = false;
+                curBranch = undefined;
+            }
+            curPath = line.slice("worktree ".length);
+        }
+        else if (line.startsWith("branch ")) {
+            curBranch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+        }
+    }
+    if (curPath !== undefined)
+        out.push({ path: curPath, branch: curBranch, isMain: first });
+    return out;
+}
+const MAX_DIFF_BYTES = 2_000_000;
+const MAX_UNTRACKED_BYTES = 200_000;
+/** Merge-base with the repo's default branch, for worktree cards; null when none is found. */
+async function defaultBranchBase(cwd) {
+    const head = await run("git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], { cwd });
+    const candidates = [head.ok ? head.stdout.trim() : "", "origin/main", "origin/master", "main", "master"].filter(Boolean);
+    for (const name of candidates) {
+        const mb = await run("git", ["merge-base", "HEAD", name], { cwd });
+        if (mb.ok && mb.stdout.trim())
+            return { sha: mb.stdout.trim(), name };
+    }
+    return null;
+}
+/**
+ * Code changes of a card's session: for a worktree, everything since it
+ * branched off the default branch; otherwise uncommitted changes vs HEAD.
+ * Untracked files are included as additions.
+ */
+export async function getDiff(cwd, isWorktree) {
+    const inside = await run("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
+    if (!inside.ok)
+        throw new Error("not a git repository");
+    const wtBase = isWorktree ? await defaultBranchBase(cwd) : null;
+    const baseRef = wtBase?.sha ?? "HEAD";
+    const r = await run("git", ["diff", "--no-color", "--no-ext-diff", baseRef], { cwd });
+    if (!r.ok)
+        throw new Error(r.stderr.trim() || "git diff failed");
+    let diff = r.stdout;
+    const untracked = await run("git", ["ls-files", "--others", "--exclude-standard", "-z"], { cwd });
+    if (untracked.ok) {
+        for (const file of untracked.stdout.split("\0").filter(Boolean)) {
+            if (diff.length > MAX_DIFF_BYTES)
+                break;
+            // --no-index exits 1 when the files differ, which is always the case here.
+            const nul = IS_WINDOWS ? "NUL" : "/dev/null";
+            const d = await run("git", ["diff", "--no-color", "--no-index", "--", nul, file], { cwd });
+            if (d.stdout)
+                diff += (diff && !diff.endsWith("\n") ? "\n" : "") + d.stdout.slice(0, MAX_UNTRACKED_BYTES);
+        }
+    }
+    const truncated = diff.length > MAX_DIFF_BYTES;
+    return { diff: truncated ? diff.slice(0, MAX_DIFF_BYTES) : diff, base: wtBase?.name ?? "HEAD", truncated };
+}
+// ── Remote URL ───────────────────────────────────────────────────────────────
+const baseUrlCache = new Map();
+export function parseGithubUrl(remote) {
+    let idx = remote.indexOf("github.com:");
+    if (idx >= 0) {
+        const p = remote.slice(idx + "github.com:".length).replace(/(\.git)+$/, "");
+        return p ? `https://github.com/${p}` : null;
+    }
+    idx = remote.indexOf("github.com/");
+    if (idx >= 0) {
+        const p = remote.slice(idx + "github.com/".length).replace(/(\.git)+$/, "");
+        return p ? `https://github.com/${p}` : null;
+    }
+    return null;
+}
+export async function githubBaseUrl(projectPath) {
+    if (baseUrlCache.has(projectPath))
+        return baseUrlCache.get(projectPath) ?? null;
+    const r = await run("git", ["remote", "get-url", "origin"], { cwd: projectPath });
+    const url = r.ok ? parseGithubUrl(r.stdout.trim()) : null;
+    baseUrlCache.set(projectPath, url);
+    return url;
+}
+export const issueUrl = (base, n) => `${base}/issues/${n}`;
+export const prUrl = (base, n) => `${base}/pull/${n}`;
+/** On WSL fall back to gh.exe when gh is only installed on the Windows side. */
+function ghBin() {
+    if (!IS_WINDOWS && isWsl())
+        return findOnPath("gh") ? "gh" : "gh.exe";
+    return "gh";
+}
+function countApprovals(reviews) {
+    if (!Array.isArray(reviews) || reviews.length === 0)
+        return undefined;
+    const latest = new Map();
+    for (const r of reviews) {
+        const author = r?.author?.login ?? "";
+        if (author)
+            latest.set(author, r?.state ?? "");
+    }
+    return [...latest.values()].filter((s) => s === "APPROVED").length;
+}
+function parseCheckRuns(rollup) {
+    if (!Array.isArray(rollup))
+        return [];
+    const out = [];
+    for (const c of rollup) {
+        const name = c?.name ?? c?.context;
+        if (typeof name !== "string")
+            continue;
+        const conclusion = c?.conclusion || c?.state || undefined;
+        out.push({ name, conclusion: conclusion || undefined });
+    }
+    return out;
+}
+export async function fetchPrs(repoRoot) {
+    const r = await run(ghBin(), [
+        "pr",
+        "list",
+        "--json",
+        "number,title,url,state,headRefName,body,mergeStateStatus,reviewDecision,reviews,statusCheckRollup",
+        "--limit",
+        "100",
+    ], { cwd: repoRoot });
+    if (!r.ok)
+        return [];
+    let prs;
+    try {
+        prs = JSON.parse(r.stdout);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const pr of prs) {
+        if (typeof pr?.number !== "number" || typeof pr.title !== "string" || typeof pr.url !== "string")
+            continue;
+        if (typeof pr.headRefName !== "string")
+            continue;
+        out.push({
+            number: pr.number,
+            title: pr.title,
+            url: pr.url,
+            state: pr.state ?? "OPEN",
+            headRef: pr.headRefName,
+            body: pr.body || undefined,
+            mergeStateStatus: pr.mergeStateStatus ?? undefined,
+            reviewDecision: pr.reviewDecision || undefined,
+            approvalCount: countApprovals(pr.reviews),
+            checkRuns: parseCheckRuns(pr.statusCheckRollup),
+        });
+    }
+    return out;
+}
+function parseOwnerRepo(url) {
+    const idx = url.indexOf("github.com/");
+    if (idx < 0)
+        return null;
+    const [owner, repo] = url.slice(idx + "github.com/".length).split("/");
+    return owner && repo ? [owner, repo] : null;
+}
+/** Unresolved review-thread counts per PR number, via one GraphQL query. */
+export async function fetchUnresolvedThreads(prs) {
+    const out = new Map();
+    if (prs.length === 0)
+        return out;
+    const parsed = parseOwnerRepo(prs[0].url);
+    if (!parsed)
+        return out;
+    const [owner, repo] = parsed;
+    const aliases = prs
+        .map((pr) => `pr${pr.number}: pullRequest(number: ${pr.number}) { reviewThreads(first: 100) { nodes { isResolved } } }`)
+        .join("\n");
+    const query = `query { repository(owner: "${owner}", name: "${repo}") { ${aliases} } }`;
+    const r = await run(ghBin(), ["api", "graphql", "-f", `query=${query}`]);
+    if (!r.ok)
+        return out;
+    try {
+        const repoNode = JSON.parse(r.stdout)?.data?.repository;
+        if (!repoNode || typeof repoNode !== "object")
+            return out;
+        for (const [alias, node] of Object.entries(repoNode)) {
+            if (!alias.startsWith("pr"))
+                continue;
+            const n = Number(alias.slice(2));
+            if (!Number.isInteger(n))
+                continue;
+            const nodes = node?.reviewThreads?.nodes ?? [];
+            out.set(n, nodes.filter((x) => x?.isResolved !== true).length);
+        }
+    }
+    catch {
+        // best effort
+    }
+    return out;
+}
+export async function fetchIssues(repoRoot, filter) {
+    const r = await run(ghBin(), ["issue", "list", "--search", filter, "--json", "number,title,url,body", "--limit", "100"], {
+        cwd: repoRoot,
+    });
+    if (!r.ok)
+        return [];
+    let issues;
+    try {
+        issues = JSON.parse(r.stdout);
+    }
+    catch {
+        return [];
+    }
+    return issues
+        .filter((i) => typeof i?.number === "number" && typeof i.title === "string" && typeof i.url === "string")
+        .map((i) => ({
+        number: i.number,
+        title: i.title,
+        url: i.url,
+        body: typeof i.body === "string" ? i.body : undefined,
+    }));
+}
+export async function ghIsAuthed() {
+    return (await run("gh", ["auth", "status"])).ok;
+}
+export async function commandExists(name) {
+    return (await run(IS_WINDOWS ? "where" : "which", [name])).ok;
+}

package/server-dist/server/harness/config.js

@@ -0,0 +1,90 @@
+// harness.json — lives at the root of the private harness repo and is the
+// same for every member: which knowledge bases exist, which project repos map
+// to which KB, and the check commands the AI-DLC skills run per project.
+import fs from "node:fs";
+import path from "node:path";
+import { run } from "../util.js";
+export const CONFIG_FILE = "harness.json";
+export function emptyConfig() {
+    return { schemaVersion: 1, kbs: [], projects: [] };
+}
+export function parseConfig(text) {
+    const raw = JSON.parse(text);
+    const kbs = Array.isArray(raw?.kbs)
+        ? raw.kbs
+            .filter((k) => typeof k?.id === "string" && typeof k?.path === "string")
+            .map((k) => ({
+            id: k.id,
+            path: k.path,
+            weight: typeof k.weight === "number" ? k.weight : undefined,
+            covers: Array.isArray(k.covers) ? k.covers.filter((c) => typeof c === "string") : undefined,
+        }))
+        : [];
+    const projects = Array.isArray(raw?.projects)
+        ? raw.projects
+            .filter((p) => typeof p?.id === "string" && typeof p?.kbId === "string")
+            .map((p) => ({
+            id: p.id,
+            name: typeof p.name === "string" ? p.name : undefined,
+            remote: typeof p.remote === "string" ? normalizeRemote(p.remote) : undefined,
+            kbId: p.kbId,
+            commands: p.commands && typeof p.commands === "object" ? p.commands : undefined,
+        }))
+        : [];
+    return { schemaVersion: typeof raw?.schemaVersion === "number" ? raw.schemaVersion : 1, kbs, projects };
+}
+export function readConfig(repoPath) {
+    try {
+        return parseConfig(fs.readFileSync(path.join(repoPath, CONFIG_FILE), "utf8"));
+    }
+    catch (e) {
+        if (e?.code === "ENOENT")
+            return emptyConfig();
+        throw new Error(`${CONFIG_FILE} is not valid: ${e?.message ?? e}`);
+    }
+}
+export function serializeConfig(c) {
+    return JSON.stringify(c, null, 2) + "\n";
+}
+/** "git@github.com:Acme/Pay.git" and "https://github.com/acme/pay" → "github.com/acme/pay". */
+export function normalizeRemote(url) {
+    let s = url.trim().toLowerCase();
+    s = s.replace(/^[a-z+]+:\/\//, "").replace(/^[^@/]+@/, "");
+    s = s.replace(/^([^/:]+):(?!\d)/, "$1/");
+    s = s.replace(/\/+$/, "").replace(/\.git$/, "");
+    return s;
+}
+/** Identify the repo a directory belongs to. Worktrees resolve to their main repo. */
+export async function repoIdentity(dir) {
+    const common = await run("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+        cwd: dir,
+        timeoutMs: 10_000,
+    });
+    if (!common.ok)
+        return null;
+    const gitDir = common.stdout.trim();
+    const root = path.basename(gitDir) === ".git" ? path.dirname(gitDir) : gitDir;
+    const origin = await run("git", ["remote", "get-url", "origin"], { cwd: dir, timeoutMs: 10_000 });
+    const remote = origin.ok && origin.stdout.trim() ? normalizeRemote(origin.stdout) : undefined;
+    return { root, remote, name: remote ? remote.split("/").pop() : path.basename(root) };
+}
+/** A project matches by remote; projects without a remote match by name. */
+export function findProject(config, id) {
+    return ((id.remote ? config.projects.find((p) => p.remote === id.remote) : undefined) ??
+        config.projects.find((p) => !p.remote && p.id === slugify(id.name)));
+}
+/** ASCII slug; accents are dropped ("Đặt hàng" → "dat-hang"). */
+export function slugify(s, fallback = "project") {
+    return (s
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[đĐ]/g, "d")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || fallback);
+}
+/** "owner/name" for GitHub remotes — the form agents.yaml expects. */
+export function ownerRepo(remote) {
+    const m = remote ? /^github\.com\/([\w.-]+\/[\w.-]+)$/.exec(remote) : null;
+    return m?.[1];
+}

package/server-dist/server/harness/entry.js

@@ -0,0 +1,98 @@
+// Knowledge entries on disk: one markdown file per entry with a YAML
+// frontmatter. The harness repo is the source of truth; everything else
+// (index, usage stats) is derived from these files.
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { KNOWLEDGE_TYPES } from "../../src/types/index.js";
+import { ksuid } from "../util.js";
+import { slugify } from "./config.js";
+export const ENTRY_SCHEMA_VERSION = 1;
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+const asString = (v) => (typeof v === "string" && v.trim() ? v.trim() : undefined);
+const asStrings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && !!x.trim()).map((x) => x.trim()) : [];
+export function isKnowledgeType(v) {
+    return typeof v === "string" && KNOWLEDGE_TYPES.includes(v);
+}
+/** Repo-relative, forward slashes, no leading "./" or "/". Folders keep a trailing "/". */
+export function normalizeScope(p) {
+    let s = p.trim().replaceAll("\\", "/");
+    while (s.startsWith("./"))
+        s = s.slice(2);
+    s = s.replace(/^\/+/, "").replace(/\/{2,}/g, "/");
+    return s;
+}
+/** Parse one entry file. Returns null when the frontmatter is missing or unusable. */
+export function parseEntry(text, kbId, filePath) {
+    const m = FRONTMATTER.exec(text);
+    if (!m)
+        return null;
+    let fm;
+    try {
+        fm = parseYaml(m[1]) ?? {};
+    }
+    catch {
+        return null;
+    }
+    const id = asString(fm.id);
+    const title = asString(fm.title);
+    if (!id || !title || !isKnowledgeType(fm.type))
+        return null;
+    const body = text.slice(m[0].length).trim();
+    const source = fm.source && typeof fm.source === "object" ? fm.source : undefined;
+    return {
+        id,
+        type: fm.type,
+        title,
+        summary: asString(fm.summary) ?? firstLine(body) ?? title,
+        body,
+        scope: asStrings(fm.scope).map(normalizeScope),
+        source: source
+            ? {
+                cardId: asString(source.cardId),
+                sessionId: asString(source.sessionId),
+                commit: asString(source.commit),
+                pr: asString(source.pr),
+            }
+            : undefined,
+        confidence: fm.confidence === "proposed" ? "proposed" : "confirmed",
+        lastVerified: asString(fm.lastVerified) ?? (fm.lastVerified instanceof Date ? isoDay(fm.lastVerified) : undefined),
+        supersedes: asStrings(fm.supersedes),
+        schemaVersion: typeof fm.schemaVersion === "number" ? fm.schemaVersion : ENTRY_SCHEMA_VERSION,
+        kbId,
+        filePath,
+    };
+}
+export function serializeEntry(e) {
+    const fm = {
+        id: e.id,
+        type: e.type,
+        title: e.title,
+        summary: e.summary,
+        scope: e.scope,
+        confidence: e.confidence,
+        lastVerified: e.lastVerified,
+        supersedes: e.supersedes,
+        schemaVersion: e.schemaVersion,
+    };
+    const source = e.source && Object.fromEntries(Object.entries(e.source).filter(([, v]) => v));
+    if (source && Object.keys(source).length)
+        fm.source = source;
+    for (const k of Object.keys(fm))
+        if (fm[k] === undefined)
+            delete fm[k];
+    return `---\n${stringifyYaml(fm).trimEnd()}\n---\n\n${e.body.trim()}\n`;
+}
+export function newEntryId() {
+    return ksuid("kb");
+}
+/** `<type>/<slug>.md` — stable and readable in a PR diff. */
+export function entryFileName(type, title, id) {
+    const slug = slugify(title, id.toLowerCase()).slice(0, 60).replace(/-+$/, "");
+    return `${type}/${slug}.md`;
+}
+export const isoDay = (d = new Date()) => d.toISOString().slice(0, 10);
+function firstLine(body) {
+    return body
+        .split(/\r?\n/)
+        .map((l) => l.replace(/^#+\s*/, "").trim())
+        .find(Boolean);
+}