@luuthuong/devboard 0.0.0-stage → 1.0.0

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);
+}