@indigoai-us/hq-cli 5.345.122 → 5.345.124

package/dist/lib/work-context/auto-bind.js

@@ -0,0 +1,245 @@
+/**
+ * WMTC-8 gap 7: resolve the project for an unbound (needs_project) session
+ * from local evidence only. No network, no subprocess, so a background hook
+ * refresh can call it cheaply. Every failure resolves to "no binding".
+ *
+ * Order:
+ *  (a) a prior binding for the same repo+branch recorded locally
+ *  (b) PRDs in the session's company whose repo AND branch match
+ *  (c) a PRD matching the repo only, when it is the single candidate
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Find the git checkout for cwd and its current branch without spawning git. */
+export function readGitLocation(cwd) {
+    let cur = path.resolve(cwd);
+    for (;;) {
+        const dotGit = path.join(cur, ".git");
+        let st;
+        try {
+            st = fs.lstatSync(dotGit);
+        }
+        catch {
+            st = null;
+        }
+        if (st) {
+            let gitDir = dotGit;
+            let mainTopLevel;
+            if (st.isFile()) {
+                const m = /^\s*gitdir:\s*(.+?)\s*$/m.exec(readText(dotGit) ?? "");
+                if (!m?.[1])
+                    return null;
+                gitDir = path.resolve(cur, m[1]);
+                const common = readText(path.join(gitDir, "commondir"))?.trim();
+                if (common)
+                    mainTopLevel = path.dirname(path.resolve(gitDir, common));
+            }
+            const head = readText(path.join(gitDir, "HEAD"))?.trim() ?? "";
+            const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
+            return {
+                topLevel: cur,
+                ...(mainTopLevel && mainTopLevel !== cur ? { mainTopLevel } : {}),
+                branch: ref?.[1] ?? null,
+            };
+        }
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            return null;
+        cur = parent;
+    }
+}
+function normRepoPath(value) {
+    return value.trim().replace(/^\.\//, "").replace(/\/+$/, "");
+}
+/** Repo identities for the checkout: HQ-relative paths and absolute paths. */
+export function repoIdentities(loc, hqRoot) {
+    const out = new Set();
+    for (const top of [loc.topLevel, loc.mainTopLevel]) {
+        if (!top)
+            continue;
+        out.add(normRepoPath(top));
+        const rel = path.relative(hqRoot, top);
+        if (rel && !rel.startsWith("..") && !path.isAbsolute(rel))
+            out.add(normRepoPath(rel));
+    }
+    return [...out];
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function prdRepoRefs(prd) {
+    const meta = asRecord(prd.metadata) ?? {};
+    const refs = [];
+    const push = (value) => {
+        if (typeof value === "string" && value.trim()) {
+            refs.push({ path: normRepoPath(value) });
+            return;
+        }
+        const r = asRecord(value);
+        if (r && typeof r.path === "string" && r.path.trim()) {
+            refs.push({
+                path: normRepoPath(r.path),
+                ...(typeof r.branch === "string" && r.branch.trim() ? { branch: r.branch.trim() } : {}),
+            });
+        }
+    };
+    for (const list of [meta.repos, meta.relatedRepos, prd.repos]) {
+        if (Array.isArray(list))
+            list.forEach(push);
+    }
+    push(meta.repoPath);
+    return refs;
+}
+/** PRDs under companies/<company>/projects/* that name this checkout. */
+export function findRepoPrdCandidates(input) {
+    const projectsDir = path.join(input.hqRoot, "companies", input.companySlug, "projects");
+    let entries;
+    try {
+        entries = fs.readdirSync(projectsDir);
+    }
+    catch {
+        return [];
+    }
+    const ids = new Set(input.identities);
+    const out = [];
+    for (const entry of entries.sort()) {
+        const prdPath = path.join(projectsDir, entry, "prd.json");
+        const raw = readText(prdPath);
+        if (!raw)
+            continue;
+        let prd;
+        try {
+            prd = asRecord(JSON.parse(raw));
+        }
+        catch {
+            continue;
+        }
+        if (!prd)
+            continue;
+        const refs = prdRepoRefs(prd).filter((ref) => ids.has(ref.path));
+        if (refs.length === 0)
+            continue;
+        const prdBranch = typeof prd.branchName === "string" ? prd.branchName.trim() : "";
+        const matchedBranch = Boolean(input.branch && (prdBranch === input.branch || refs.some((ref) => ref.branch === input.branch)));
+        const meta = asRecord(prd.metadata);
+        const projectId = (typeof prd.projectId === "string" && prd.projectId.trim())
+            || (typeof meta?.projectId === "string" && meta.projectId.trim())
+            || entry;
+        out.push({ projectId, prdPath, matchedBranch });
+    }
+    return out;
+}
+export function autoBindHistoryPath(workContextRoot) {
+    return path.join(workContextRoot, "auto-bind-history.json");
+}
+function historyKey(companySlug, repo, branch) {
+    return `${companySlug}|${repo}@${branch}`;
+}
+function readHistory(workContextRoot) {
+    const raw = readText(autoBindHistoryPath(workContextRoot));
+    if (!raw)
+        return {};
+    try {
+        return (asRecord(JSON.parse(raw)) ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+export function lookupPriorBinding(input) {
+    if (!input.branch)
+        return null;
+    const history = readHistory(input.workContextRoot);
+    for (const repo of input.identities) {
+        const hit = history[historyKey(input.companySlug, repo, input.branch)];
+        if (hit?.projectId)
+            return hit.projectId;
+    }
+    return null;
+}
+/** Remember a binding for this repo+branch. Best-effort; never throws. */
+export function recordPriorBinding(input) {
+    if (!input.branch || input.identities.length === 0)
+        return;
+    try {
+        const history = readHistory(input.workContextRoot);
+        const at = (input.now ?? new Date()).toISOString();
+        for (const repo of input.identities) {
+            history[historyKey(input.companySlug, repo, input.branch)] = {
+                projectId: input.projectId,
+                companySlug: input.companySlug,
+                at,
+            };
+        }
+        const file = autoBindHistoryPath(input.workContextRoot);
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const tmp = `${file}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, `${JSON.stringify(history, null, 2)}\n`, { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        /* history is a hint only */
+    }
+}
+// ---------------------------------------------------------------------------
+// Decision
+// ---------------------------------------------------------------------------
+export function decideAutoBind(input) {
+    const { state } = input;
+    if (!state)
+        return { action: "noop", reason: "no_session" };
+    if (state.contextStatus !== "needs_project") {
+        if (state.projectId)
+            return { action: "noop", reason: "already_bound", projectId: state.projectId };
+        return { action: "noop", reason: "not_needs_project" };
+    }
+    const companySlug = input.companySlug?.trim() || state.companySlug?.trim();
+    if (!companySlug)
+        return { action: "skip", reason: "no_company", candidates: [] };
+    const git = readGitLocation(input.cwd);
+    if (!git)
+        return { action: "skip", reason: "no_git", candidates: [] };
+    const identities = repoIdentities(git, input.hqRoot);
+    const extra = { git, identities };
+    const prior = lookupPriorBinding({
+        workContextRoot: input.workContextRoot,
+        companySlug,
+        identities,
+        branch: git.branch,
+    });
+    const candidates = findRepoPrdCandidates({
+        hqRoot: input.hqRoot,
+        companySlug,
+        identities,
+        branch: git.branch,
+    });
+    if (prior)
+        return { action: "bind", projectId: prior, source: "history", candidates, ...extra };
+    const branchMatches = candidates.filter((c) => c.matchedBranch);
+    if (branchMatches.length === 1) {
+        return { action: "bind", projectId: branchMatches[0].projectId, source: "repo_branch", candidates, ...extra };
+    }
+    if (branchMatches.length > 1) {
+        return { action: "skip", reason: "ambiguous", candidates: branchMatches, ...extra };
+    }
+    if (candidates.length === 1) {
+        return { action: "bind", projectId: candidates[0].projectId, source: "repo_only", candidates, ...extra };
+    }
+    return {
+        action: "skip",
+        reason: candidates.length ? "ambiguous" : "no_match",
+        candidates,
+        ...extra,
+    };
+}
+//# sourceMappingURL=auto-bind.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.122",
+  "version": "5.345.124",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {