@indigoai-us/hq-cli 5.345.123 → 5.345.125

package/dist/lib/mesh/team-coordination.js

@@ -0,0 +1,297 @@
+/**
+ * Work Mesh team coordination (WMTC-7 / WMTC-8): story claims, overlap,
+ * project reassignment, assignee suggestions, and the presence roster.
+ *
+ * Every route here except the story PATCH is new on hq-pro. Callers treat a
+ * 404/405 without an error code as "this server does not have the route yet"
+ * and degrade to one plain line instead of failing.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { meshJson } from "./api.js";
+import { meshCacheRoot } from "./cache.js";
+export const STORY_ASSIGNEE_CONFLICT = "STORY_ASSIGNEE_CONFLICT";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function str(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function strArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/**
+ * True when the server does not know the route: 405, or a 404 that carries no
+ * error code. A coded 404 (for example PROJECT_NOT_FOUND) is a real answer.
+ */
+export function isRouteUnavailable(err) {
+    const e = err;
+    if (!e || typeof e !== "object")
+        return false;
+    if (e.status === 405)
+        return true;
+    return e.status === 404 && !e.code;
+}
+export function unavailableLine(feature) {
+    return `${feature} is not available on this server yet`;
+}
+/** Extract a structured conflict from a 409 meshJson failure, if it is one. */
+export function storyConflictFromError(err) {
+    const e = err;
+    if (!e || typeof e !== "object" || e.status !== 409 || e.code !== STORY_ASSIGNEE_CONFLICT)
+        return null;
+    const body = asRecord(e.body) ?? {};
+    const holderDisplayName = str(body.holderDisplayName);
+    return {
+        code: STORY_ASSIGNEE_CONFLICT,
+        error: str(body.error) ?? e.message,
+        holderUid: str(body.holderUid) ?? "",
+        ...(holderDisplayName ? { holderDisplayName } : {}),
+    };
+}
+export function formatStoryConflictLine(storyId, conflict, names) {
+    const name = conflict.holderDisplayName || names?.get(conflict.holderUid) || "another teammate";
+    const uid = conflict.holderUid ? ` (${conflict.holderUid})` : "";
+    return `Story ${storyId} is assigned to ${name}${uid}. Ask them to hand it off, or re-run with --force.`;
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function peopleFromPayload(payload) {
+    const rec = asRecord(payload);
+    const rows = Array.isArray(payload)
+        ? payload
+        : [
+            ...(Array.isArray(rec?.contacts) ? rec.contacts : []),
+            ...(Array.isArray(rec?.rows) ? rec.rows : []),
+            ...(Array.isArray(rec?.members) ? rec.members : []),
+        ];
+    const out = [];
+    for (const row of rows) {
+        const r = asRecord(row);
+        if (!r)
+            continue;
+        const uid = str(r.personUid) ?? str(r.actorUid) ?? str(r.uid);
+        if (!uid || !/^(prs|agt)_/.test(uid))
+            continue;
+        const displayName = str(r.displayName);
+        const email = str(r.email);
+        out.push({ uid, ...(displayName ? { displayName } : {}), ...(email ? { email } : {}) });
+    }
+    return out;
+}
+/** People known from the local contacts/directory cache. Never throws. */
+export function loadCachedPeople(cacheRoot = meshCacheRoot()) {
+    const people = new Map();
+    for (const dir of ["contacts", "directory"]) {
+        let files;
+        try {
+            files = fs.readdirSync(path.join(cacheRoot, dir)).filter((f) => f.endsWith(".json"));
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            for (const person of peopleFromPayload(readJson(path.join(cacheRoot, dir, file)))) {
+                const prior = people.get(person.uid);
+                const displayName = prior?.displayName ?? person.displayName;
+                const email = prior?.email ?? person.email;
+                people.set(person.uid, {
+                    uid: person.uid,
+                    ...(displayName ? { displayName } : {}),
+                    ...(email ? { email } : {}),
+                });
+            }
+        }
+    }
+    return [...people.values()];
+}
+export function loadNameDirectory(cacheRoot = meshCacheRoot()) {
+    const names = new Map();
+    for (const person of loadCachedPeople(cacheRoot)) {
+        if (person.displayName)
+            names.set(person.uid, person.displayName);
+    }
+    return names;
+}
+export function displayNameFor(uid, serverName, names) {
+    return serverName?.trim() || names.get(uid) || uid;
+}
+/** Resolve a uid, email, or display name against a list of people. */
+export function resolvePerson(query, people) {
+    const q = query.trim();
+    if (/^(prs|agt)_/.test(q)) {
+        const known = people.find((p) => p.uid === q);
+        return { ok: true, uid: q, ...(known?.displayName ? { displayName: known.displayName } : {}) };
+    }
+    const lower = q.toLowerCase();
+    const exact = people.filter((p) => p.email?.toLowerCase() === lower || p.displayName?.toLowerCase() === lower);
+    const matches = exact.length
+        ? exact
+        : people.filter((p) => p.displayName?.toLowerCase().split(/\s+/)[0] === lower);
+    if (matches.length === 1) {
+        const m = matches[0];
+        return { ok: true, uid: m.uid, ...(m.displayName ? { displayName: m.displayName } : {}) };
+    }
+    return { ok: false, reason: matches.length ? "ambiguous" : "none", candidates: matches };
+}
+export const OVERLAP_MAX_FILES = 200;
+export async function postOverlap(token, req) {
+    const body = {
+        companyUid: req.companyUid,
+        sessionId: req.sessionId,
+        repo: req.repo,
+        branch: req.branch,
+    };
+    if (req.projectId)
+        body.projectId = req.projectId;
+    if (req.storyId)
+        body.storyId = req.storyId;
+    if (req.files?.length)
+        body.files = req.files.slice(0, OVERLAP_MAX_FILES);
+    const data = asRecord(await meshJson(token, "/v1/work-mesh/overlap", { method: "POST", body }));
+    const rows = Array.isArray(data?.overlaps) ? data.overlaps : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        const projectId = str(r.projectId);
+        const storyId = str(r.storyId);
+        const lastSeenAt = str(r.lastSeenAt);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                sessionId: str(r.sessionId) ?? "",
+                repo: str(r.repo) ?? "",
+                branch: str(r.branch) ?? "",
+                ...(projectId ? { projectId } : {}),
+                ...(storyId ? { storyId } : {}),
+                reasons: strArray(r.reasons),
+                sharedFiles: strArray(r.sharedFiles),
+                ...(lastSeenAt ? { lastSeenAt } : {}),
+            }];
+    });
+}
+export function formatOverlapLines(overlaps, names) {
+    if (overlaps.length === 0)
+        return ["No overlapping work found."];
+    const lines = [`${overlaps.length} overlapping session${overlaps.length === 1 ? "" : "s"}:`];
+    for (const o of overlaps) {
+        const who = displayNameFor(o.actorUid, o.displayName, names);
+        const where = [
+            o.repo ? `${o.repo}@${o.branch}` : "",
+            o.projectId ? `project ${o.projectId}` : "",
+            o.storyId ? `story ${o.storyId}` : "",
+        ].filter(Boolean).join(", ");
+        lines.push(`- ${who} in session ${o.sessionId}: same ${o.reasons.join(" + ") || "work"}${where ? ` (${where})` : ""}`);
+        if (o.sharedFiles.length) {
+            const shown = o.sharedFiles.slice(0, 10);
+            const more = o.sharedFiles.length - shown.length;
+            lines.push(`  shared files: ${shown.join(", ")}${more > 0 ? ` (+${more} more)` : ""}`);
+        }
+    }
+    return lines;
+}
+export async function postProjectReassign(token, projectId, body) {
+    const payload = { companyUid: body.companyUid, toUid: body.toUid };
+    if (body.includeOpenStories)
+        payload.includeOpenStories = true;
+    if (body.note)
+        payload.note = body.note;
+    const data = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/reassign`, { method: "POST", body: payload }));
+    return {
+        projectId: str(data?.projectId) ?? projectId,
+        ownerUid: str(data?.ownerUid) ?? body.toUid,
+        previousOwnerUid: str(data?.previousOwnerUid) ?? null,
+        reassignedStories: strArray(data?.reassignedStories),
+    };
+}
+export async function fetchStorySuggestions(token, companyUid, projectId, storyId) {
+    const data = asRecord(await meshJson(token, `/v1/work-mesh/projects/${encodeURIComponent(projectId)}/stories/${encodeURIComponent(storyId)}/suggestions`, { query: { companyUid } }));
+    const rows = Array.isArray(data?.candidates) ? data.candidates : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                score: typeof r.score === "number" ? r.score : 0,
+                idle: r.idle === true,
+                reasons: strArray(r.reasons),
+            }];
+    });
+}
+export function formatSuggestionLines(storyId, candidates, names) {
+    if (candidates.length === 0)
+        return [`No suggested assignees for ${storyId}.`];
+    const lines = [`Suggested assignees for ${storyId}:`];
+    candidates.forEach((c, i) => {
+        const who = displayNameFor(c.actorUid, c.displayName, names);
+        const why = c.reasons.length ? `: ${c.reasons.join("; ")}` : "";
+        lines.push(`${i + 1}. ${who} (${c.actorUid}) score ${c.score}${c.idle ? ", idle" : ""}${why}`);
+    });
+    return lines;
+}
+export async function fetchRoster(token, companyUid) {
+    const data = asRecord(await meshJson(token, "/v1/work-mesh/live/roster", { query: { companyUid } }));
+    const rows = Array.isArray(data?.members) ? data.members : [];
+    return rows.flatMap((row) => {
+        const r = asRecord(row);
+        const actorUid = str(r?.actorUid);
+        if (!r || !actorUid)
+            return [];
+        const displayName = str(r.displayName);
+        const actorType = str(r.actorType);
+        return [{
+                actorUid,
+                ...(displayName ? { displayName } : {}),
+                ...(actorType ? { actorType } : {}),
+                daemonLastSeenAt: str(r.daemonLastSeenAt) ?? null,
+                lastSessionAt: str(r.lastSessionAt) ?? null,
+                boundSessions: typeof r.boundSessions === "number" ? r.boundSessions : 0,
+                unboundSessions: typeof r.unboundSessions === "number" ? r.unboundSessions : 0,
+            }];
+    });
+}
+export function rosterFlags(member) {
+    const flags = [];
+    if (!member.daemonLastSeenAt)
+        flags.push("no daemon report");
+    if (member.unboundSessions > 0 && member.boundSessions === 0)
+        flags.push("only unbound sessions");
+    return flags;
+}
+export function formatRosterLines(members, companyLabel, names) {
+    const lines = [
+        `Work mesh roster: ${companyLabel}`,
+        "name\tdaemon last seen\tlast session\tbound\tunbound\tflags",
+    ];
+    for (const m of members) {
+        lines.push([
+            displayNameFor(m.actorUid, m.displayName, names),
+            m.daemonLastSeenAt ?? "never",
+            m.lastSessionAt ?? "never",
+            String(m.boundSessions),
+            String(m.unboundSessions),
+            rosterFlags(m).join(", ") || "-",
+        ].join("\t"));
+    }
+    return lines;
+}
+//# sourceMappingURL=team-coordination.js.map

package/dist/lib/work-context/auto-bind.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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 type { SessionStateFile } from "./state.js";
+export interface GitLocation {
+    /** Absolute top-level of the checkout containing cwd. */
+    topLevel: string;
+    /** Main checkout top-level when cwd is a linked worktree. */
+    mainTopLevel?: string;
+    branch: string | null;
+}
+export interface AutoBindCandidate {
+    projectId: string;
+    prdPath: string;
+    matchedBranch: boolean;
+}
+export type AutoBindDecision = {
+    action: "noop";
+    reason: "already_bound" | "not_needs_project" | "no_session";
+    projectId?: string;
+} | {
+    action: "bind";
+    projectId: string;
+    source: "history" | "repo_branch" | "repo_only";
+    candidates: AutoBindCandidate[];
+} | {
+    action: "skip";
+    reason: "no_git" | "no_company" | "no_match" | "ambiguous";
+    candidates: AutoBindCandidate[];
+};
+/** Find the git checkout for cwd and its current branch without spawning git. */
+export declare function readGitLocation(cwd: string): GitLocation | null;
+/** Repo identities for the checkout: HQ-relative paths and absolute paths. */
+export declare function repoIdentities(loc: GitLocation, hqRoot: string): string[];
+/** PRDs under companies/<company>/projects/* that name this checkout. */
+export declare function findRepoPrdCandidates(input: {
+    hqRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+}): AutoBindCandidate[];
+export declare function autoBindHistoryPath(workContextRoot: string): string;
+export declare function lookupPriorBinding(input: {
+    workContextRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+}): string | null;
+/** Remember a binding for this repo+branch. Best-effort; never throws. */
+export declare function recordPriorBinding(input: {
+    workContextRoot: string;
+    companySlug: string;
+    identities: string[];
+    branch: string | null;
+    projectId: string;
+    now?: Date;
+}): void;
+export declare function decideAutoBind(input: {
+    state: SessionStateFile | null;
+    cwd: string;
+    hqRoot: string;
+    workContextRoot: string;
+    companySlug?: string;
+}): AutoBindDecision & {
+    git?: GitLocation;
+    identities?: string[];
+};
+//# sourceMappingURL=auto-bind.d.ts.map

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.123",
+  "version": "5.345.125",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {