@bli-cockpit/cli 0.1.2 → 0.1.5

package/dist/repo-identity.js

@@ -0,0 +1,203 @@
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const SKIPPED_DIR_NAMES = new Set([
+    ".cache",
+    ".git",
+    ".next",
+    ".turbo",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "out",
+]);
+export async function resolveRepoWorktreeIdentity(repoRoot) {
+    const requestedPath = path.resolve(repoRoot);
+    const gitRoot = await runGit(["rev-parse", "--show-toplevel"], requestedPath);
+    const resolvedRoot = path.resolve(gitRoot.trim() || requestedPath);
+    const branch = await resolveGitBranchWithGit(resolvedRoot);
+    const headSha = await runGit(["rev-parse", "HEAD"], resolvedRoot).then((value) => value.trim() || null, () => null);
+    const absoluteGitDir = await runGit(["rev-parse", "--absolute-git-dir"], resolvedRoot)
+        .then((value) => path.resolve(resolvedRoot, value.trim()))
+        .catch(() => null);
+    const commonGitDir = await runGit(["rev-parse", "--git-common-dir"], resolvedRoot)
+        .then((value) => path.resolve(resolvedRoot, value.trim()))
+        .catch(() => absoluteGitDir ?? resolvedRoot);
+    const rawOrigin = await runGit(["remote", "get-url", "origin"], resolvedRoot).then((value) => value.trim() || null, () => null);
+    const repoOriginUrl = rawOrigin ? normalizeGitOrigin(rawOrigin) : null;
+    const repoLabel = repoOriginUrl
+        ? repoLabelFromOrigin(repoOriginUrl)
+        : path.basename(resolvedRoot);
+    const repoMaterial = repoOriginUrl
+        ? `origin:${repoOriginUrl}`
+        : `local:${sha256(commonGitDir ?? resolvedRoot)}`;
+    const repoFingerprint = `repo-${sha256(repoMaterial).slice(0, 24)}`;
+    const worktreeMaterial = [
+        repoFingerprint,
+        resolvedRoot,
+        commonGitDir ?? "",
+    ].join("\n");
+    const gitFilePath = path.join(resolvedRoot, ".git");
+    const worktreeIsPrimary = await fs.stat(gitFilePath).then((stat) => stat.isDirectory(), () => false);
+    return {
+        requested_path: requestedPath,
+        repo_root: resolvedRoot,
+        repo_label: repoLabel,
+        repo_fingerprint: repoFingerprint,
+        repo_origin_url: repoOriginUrl,
+        branch,
+        head_sha: headSha,
+        worktree_label: path.basename(resolvedRoot),
+        worktree_fingerprint: `wt-${sha256(worktreeMaterial).slice(0, 24)}`,
+        worktree_is_primary: worktreeIsPrimary,
+    };
+}
+export async function discoverGitWorktrees(root, options = {}) {
+    const resolvedRoot = path.resolve(root);
+    const direct = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
+    if (direct)
+        return [direct];
+    if (await hasGitMarker(resolvedRoot)) {
+        return [await fallbackFilesystemIdentity(resolvedRoot)];
+    }
+    const maxDepth = options.maxDepth ?? 2;
+    const maxWorktrees = options.maxWorktrees ?? 50;
+    const discovered = new Map();
+    const stack = [{ dir: resolvedRoot, depth: 0 }];
+    const visited = new Set();
+    while (stack.length > 0 && discovered.size < maxWorktrees) {
+        const current = stack.shift();
+        if (!current)
+            continue;
+        const real = await fs.realpath(current.dir).catch(() => current.dir);
+        if (visited.has(real))
+            continue;
+        visited.add(real);
+        if (await hasGitMarker(current.dir)) {
+            const identity = (await resolveRepoWorktreeIdentity(current.dir).catch(() => null)) ??
+                (await fallbackFilesystemIdentity(current.dir));
+            discovered.set(identity.worktree_fingerprint, identity);
+            continue;
+        }
+        if (current.depth >= maxDepth)
+            continue;
+        const entries = await fs.readdir(current.dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.isDirectory() || shouldSkipDirectory(entry.name))
+                continue;
+            stack.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
+        }
+    }
+    return [...discovered.values()].sort(compareIdentity);
+}
+async function hasGitMarker(dir) {
+    return fs.stat(path.join(dir, ".git")).then((stat) => stat.isDirectory() || stat.isFile(), () => false);
+}
+async function fallbackFilesystemIdentity(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const repoLabel = path.basename(resolvedRoot) || "repo";
+    const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
+    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
+    return {
+        requested_path: resolvedRoot,
+        repo_root: resolvedRoot,
+        repo_label: repoLabel,
+        repo_fingerprint: repoFingerprint,
+        repo_origin_url: null,
+        branch: await resolveBranchFromHead(resolvedRoot),
+        head_sha: null,
+        worktree_label: repoLabel,
+        worktree_fingerprint: worktreeFingerprint,
+        worktree_is_primary: true,
+    };
+}
+async function resolveBranchFromHead(repoRoot) {
+    try {
+        const gitPath = path.join(repoRoot, ".git");
+        const stat = await fs.stat(gitPath);
+        const headPath = stat.isFile()
+            ? path.join(await resolveLinkedGitDir(gitPath), "HEAD")
+            : path.join(gitPath, "HEAD");
+        const head = (await fs.readFile(headPath, "utf8")).trim();
+        if (head.startsWith("ref: refs/heads/")) {
+            return head.slice("ref: refs/heads/".length);
+        }
+        return head ? `detached:${head.slice(0, 12)}` : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+async function resolveLinkedGitDir(gitFile) {
+    const raw = await fs.readFile(gitFile, "utf8");
+    const match = raw.match(/^gitdir:\s*(.+)$/m);
+    if (!match)
+        return path.dirname(gitFile);
+    const gitDir = match[1].trim();
+    return path.isAbsolute(gitDir) ? gitDir : path.resolve(path.dirname(gitFile), gitDir);
+}
+export function normalizeGitOrigin(rawOrigin) {
+    const trimmed = rawOrigin.trim();
+    if (!trimmed)
+        return "";
+    const scpLike = trimmed.match(/^(?:[^@]+@)?([^:]+):(.+)$/);
+    if (scpLike && !trimmed.includes("://")) {
+        return normalizeOriginParts(scpLike[1] ?? "", scpLike[2] ?? "");
+    }
+    try {
+        const url = new URL(trimmed);
+        return normalizeOriginParts(url.hostname, url.pathname);
+    }
+    catch {
+        return trimmed
+            .replace(/\.git$/i, "")
+            .replace(/^\/+|\/+$/g, "")
+            .toLowerCase();
+    }
+}
+export function repoLabelFromOrigin(origin) {
+    const segments = origin.split("/").filter(Boolean);
+    return segments.at(-1) ?? origin;
+}
+function normalizeOriginParts(host, repoPath) {
+    return [
+        host.trim().toLowerCase(),
+        repoPath
+            .trim()
+            .replace(/\.git$/i, "")
+            .replace(/^\/+|\/+$/g, "")
+            .toLowerCase(),
+    ]
+        .filter(Boolean)
+        .join("/");
+}
+function shouldSkipDirectory(name) {
+    return name.startsWith(".") || SKIPPED_DIR_NAMES.has(name);
+}
+function compareIdentity(a, b) {
+    return (a.repo_label.localeCompare(b.repo_label) ||
+        Number(b.worktree_is_primary) - Number(a.worktree_is_primary) ||
+        a.worktree_label.localeCompare(b.worktree_label));
+}
+async function resolveGitBranchWithGit(repoRoot) {
+    const branch = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot).then((value) => value.trim(), () => "");
+    if (branch && branch !== "HEAD")
+        return branch;
+    const head = await runGit(["rev-parse", "--short=12", "HEAD"], repoRoot).then((value) => value.trim(), () => "");
+    return head ? `detached:${head}` : "unknown";
+}
+async function runGit(args, cwd) {
+    const { stdout } = await execFileAsync("git", args, {
+        cwd,
+        timeout: 2_000,
+        maxBuffer: 1024 * 1024,
+    });
+    return stdout;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value, "utf8").digest("hex");
+}

package/dist/server.js

@@ -1,4 +1,4 @@
-import { getCollectorRuntimePaths, inspectLocalCollectorStatus, readLocalSessionReference, readLocalWorkContext, } from "./local-state.js";
+import { getCollectorRuntimePaths, inspectLocalCollectorStatus, readLocalSessionReference, readLocalWorkContext, readLocalWorkContextForRepo, } from "./local-state.js";
 import { runLocalSourceCollectors } from "./adapters/local-sources.js";
 import http from "node:http";
 export function createCollectorServer(options = {}) {
@@ -55,7 +55,9 @@ export function isLoopbackHostHeader(hostHeader) {
 }
 async function contextPayload(options) {
     const paths = getCollectorRuntimePaths(options.homeDir);
-    const context = await readLocalWorkContext(paths).catch(() => null);
+    const context = options.repoRoot
+        ? await readLocalWorkContextForRepo(paths, options.repoRoot).catch(() => null)
+        : await readLocalWorkContext(paths).catch(() => null);
     return { context };
 }
 async function sourcesPayload(options) {
@@ -73,7 +75,9 @@ async function flagsPayload(options) {
 async function collectLocalSources(options) {
     const status = await inspectLocalCollectorStatus(options);
     const paths = getCollectorRuntimePaths(options.homeDir);
-    const activeContext = await readLocalWorkContext(paths).catch(() => null);
+    const activeContext = options.repoRoot
+        ? await readLocalWorkContextForRepo(paths, options.repoRoot).catch(() => null)
+        : await readLocalWorkContext(paths).catch(() => null);
     const session = await readLocalSessionReference(paths);
     const workContextId = activeContext?.work_context_id ?? status.work_context_id ?? "status-only";
     const sources = await runLocalSourceCollectors({