@indigoai-us/hq-cli 5.234.2 → 5.235.0

package/dist/lib/lanes/tracker-mesh-questions.js

@@ -1,138 +0,0 @@
-import { meshJson, requireToken } from "../mesh/client.js";
-import { LanesError } from "./errors.js";
-import { mapWorkMeshTrackerError } from "./tracker-mesh.js";
-/** Persist a local delivery checkpoint only after the Work Mesh stamp succeeds. */
-export async function deliverTrackerMeshQuestionOnce(question, company, client, persist) {
-    if (!question.mesh_question_id || question.status !== "answered" ||
-        !question.delivered_at || question.mesh_delivered_at)
-        return question;
-    const delivered = await client.delivered(question.mesh_question_id);
-    if (delivered.questionId !== question.mesh_question_id ||
-        delivered.companyUid !== company.uid ||
-        delivered.laneId !== question.lane_id ||
-        delivered.projectId !== question.project_id ||
-        !delivered.deliveredAt) {
-        throw new LanesError("tracker_mesh_response_invalid", "Work Mesh did not stamp the expected question as delivered", {
-            mesh_question_id: question.mesh_question_id,
-            question_id: question.question_id,
-        });
-    }
-    return persist(delivered.deliveredAt);
-}
-const ROOT = "/v1/work-mesh/tracker/questions";
-const AUDIENCES = ["owner", "operator", "lane"];
-const STATUSES = ["pending", "answered", "cancelled"];
-const MAX_PAGES_PER_FILTER = 10;
-function invalidResponse(field) {
-    throw new LanesError("tracker_mesh_response_invalid", `Work Mesh returned an invalid tracker question ${field}`, { field });
-}
-function parseQuestion(raw, company) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return invalidResponse("row");
-    const row = raw;
-    if (typeof row.questionId !== "string" || !row.questionId ||
-        typeof row.threadId !== "string" || !row.threadId ||
-        row.companyUid !== company.uid ||
-        typeof row.projectId !== "string" || !row.projectId ||
-        typeof row.laneId !== "string" || !row.laneId ||
-        !AUDIENCES.includes(row.audience) ||
-        !STATUSES.includes(row.status) ||
-        typeof row.question !== "string" ||
-        !Array.isArray(row.options) || row.options.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.audienceChain) || row.audienceChain.some((entry) => typeof entry !== "string") ||
-        !Array.isArray(row.routingHistory) ||
-        typeof row.askedAt !== "string" || !Number.isFinite(Date.parse(row.askedAt)))
-        return invalidResponse("row");
-    if (row.context !== undefined && typeof row.context !== "string")
-        return invalidResponse("context");
-    if (row.recommended !== undefined && typeof row.recommended !== "string")
-        return invalidResponse("recommended");
-    if (row.choice !== undefined && typeof row.choice !== "string")
-        return invalidResponse("choice");
-    if (row.notes !== undefined && typeof row.notes !== "string")
-        return invalidResponse("notes");
-    if (row.answeredBy !== undefined && typeof row.answeredBy !== "string")
-        return invalidResponse("answeredBy");
-    if (row.answeredAt !== undefined && (typeof row.answeredAt !== "string" || !Number.isFinite(Date.parse(row.answeredAt))))
-        return invalidResponse("answeredAt");
-    if (row.deliveredAt !== undefined && (typeof row.deliveredAt !== "string" || !Number.isFinite(Date.parse(row.deliveredAt))))
-        return invalidResponse("deliveredAt");
-    if (!row.host || typeof row.host !== "object" || Array.isArray(row.host) || typeof row.host.kind !== "string" || typeof row.host.id !== "string")
-        return invalidResponse("host");
-    return row;
-}
-export function createTrackerMeshQuestionClient(options) {
-    const { company } = options;
-    if (!company.slug.trim() || !company.uid.trim()) {
-        throw new LanesError("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker questions", {});
-    }
-    const request = options.request ?? (async (endpoint, init) => {
-        const token = await requireToken({ interactive: false });
-        return meshJson(token, endpoint, init);
-    });
-    const call = async (endpoint, init) => {
-        try {
-            const result = await request(endpoint, init);
-            if (!result || typeof result !== "object" || Array.isArray(result))
-                return invalidResponse("response");
-            return result;
-        }
-        catch (err) {
-            throw mapWorkMeshTrackerError(err);
-        }
-    };
-    return {
-        async create(input) {
-            const result = await call(ROOT, { method: "POST", body: { companyUid: company.uid, ...input } });
-            return parseQuestion(result.question, company);
-        },
-        async list(requestedStatuses = STATUSES) {
-            const uniqueStatuses = [...new Set(requestedStatuses)];
-            if (uniqueStatuses.some((status) => !STATUSES.includes(status))) {
-                throw new LanesError("tracker_mesh_query_invalid", "Unsupported Work Mesh tracker question status filter", { statuses: uniqueStatuses });
-            }
-            const rows = new Map();
-            for (const audience of AUDIENCES) {
-                for (const status of uniqueStatuses) {
-                    let cursor;
-                    for (let page = 0; page < MAX_PAGES_PER_FILTER; page += 1) {
-                        const query = { companyUid: company.uid, audience, status, limit: "100", ...(cursor ? { cursor } : {}) };
-                        const result = await call(ROOT, { method: "GET", query });
-                        if (!Array.isArray(result.questions))
-                            return invalidResponse("questions list");
-                        for (const raw of result.questions) {
-                            const row = parseQuestion(raw, company);
-                            if (row.audience !== audience || row.status !== status)
-                                return invalidResponse("filter scope");
-                            rows.set(row.questionId, row);
-                        }
-                        if (result.nextCursor === undefined)
-                            break;
-                        if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor)
-                            return invalidResponse("cursor");
-                        if (page === MAX_PAGES_PER_FILTER - 1) {
-                            throw new LanesError("tracker_mesh_response_incomplete", "Work Mesh tracker question list exceeded its bounded page limit", { audience, status, max_pages: MAX_PAGES_PER_FILTER });
-                        }
-                        cursor = result.nextCursor;
-                    }
-                }
-            }
-            return [...rows.values()].sort((a, b) => b.askedAt.localeCompare(a.askedAt) || a.questionId.localeCompare(b.questionId));
-        },
-        async answer(questionId, choice, notes) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/answer`, {
-                method: "POST",
-                body: { companyUid: company.uid, choice, ...(notes === undefined ? {} : { notes }) },
-            });
-            return parseQuestion(result.question, company);
-        },
-        async delivered(questionId) {
-            const result = await call(`${ROOT}/${encodeURIComponent(questionId)}/delivered`, {
-                method: "POST",
-                body: { companyUid: company.uid },
-            });
-            return parseQuestion(result.question, company);
-        },
-    };
-}
-//# sourceMappingURL=tracker-mesh-questions.js.map

package/dist/lib/lanes/tracker-mesh.d.ts

@@ -1,19 +0,0 @@
-import { LanesError } from "./errors.js";
-import type { LaneCompanyRef } from "./types.js";
-import type { TrackerStore } from "./tracker-store.js";
-export interface TrackerMeshRequestInit {
-    method?: string;
-    body?: Record<string, unknown>;
-    query?: Record<string, string>;
-}
-export type TrackerMeshRequest = (path: string, init: TrackerMeshRequestInit) => Promise<unknown>;
-export interface WorkMeshTrackerStoreOptions {
-    company: LaneCompanyRef;
-    projectId: string;
-    request?: TrackerMeshRequest;
-    now?: () => Date;
-    clientRecordId?: () => string;
-}
-export declare function mapWorkMeshTrackerError(err: unknown): LanesError;
-export declare function createWorkMeshTrackerStore(options: WorkMeshTrackerStoreOptions): TrackerStore;
-//# sourceMappingURL=tracker-mesh.d.ts.map

package/dist/lib/lanes/tracker-mesh.js

@@ -1,251 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { meshJson, requireToken } from "../mesh/client.js";
-import { LanesError } from "./errors.js";
-const ROOT = "/v1/work-mesh/tracker/records";
-const MAX_RECORD_PAGES = 20;
-const RECORD_FIELDS = {
-    blocker: ["story_id", "what", "waiting_on", "next_step", "opened_at", "resolved_at", "resolution", "import_key", "source_path", "source_item_id"],
-    kpi: ["name", "definition", "unit", "target", "direction", "status", "approved_by", "approved_at", "values", "import_key", "source_path", "source_item_id"],
-    okr: ["objective", "period", "key_results", "status", "approved_by", "approved_at", "import_key", "source_path", "source_item_id"],
-    directive: ["text", "date", "source_url", "teams", "policy_path", "acknowledgements", "import_key", "source_path", "source_item_id"],
-};
-function fail(error, message, details = {}) {
-    throw new LanesError(error, message, details);
-}
-export function mapWorkMeshTrackerError(err) {
-    if (err instanceof LanesError)
-        return err;
-    const value = err;
-    const status = typeof value?.status === "number" ? value.status : Number(/^\s*(\d{3})\b/.exec(err instanceof Error ? err.message : "")?.[1]);
-    const code = typeof value?.code === "string" ? value.code : "";
-    if (status === 404 && code === "tracker_records_disabled") {
-        return new LanesError("tracker_records_disabled", "Work Mesh tracker records are disabled for this company", { status, code });
-    }
-    if (status === 404)
-        return new LanesError("tracker_record_not_found", "Work Mesh tracker record was not found", { status, code });
-    if (status === 409 && (code === "stale_version" || /stale.version/i.test(err instanceof Error ? err.message : ""))) {
-        return new LanesError("tracker_version_conflict", "Work Mesh tracker record changed before this update", { status, code });
-    }
-    if (status === 409)
-        return new LanesError("tracker_mesh_conflict", "Work Mesh rejected the tracker update because the record state changed", { status, code });
-    if (status === 401 || status === 403)
-        return new LanesError("tracker_mesh_auth_failed", "Work Mesh tracker access was denied for this company", { status, code });
-    if (status === 400 || status === 422)
-        return new LanesError("tracker_mesh_validation_failed", "Work Mesh rejected the tracker record data", { status, code });
-    return new LanesError("tracker_mesh_unavailable", `Work Mesh tracker request failed: ${err instanceof Error ? err.message : String(err)}`, { status: Number.isFinite(status) ? status : undefined });
-}
-function toMesh(value) {
-    if (Array.isArray(value))
-        return value.map(toMesh);
-    if (!value || typeof value !== "object")
-        return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-        key.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase()),
-        toMesh(item),
-    ]));
-}
-function fromMesh(value) {
-    if (Array.isArray(value))
-        return value.map(fromMesh);
-    if (!value || typeof value !== "object")
-        return value;
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-        key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`),
-        fromMesh(item),
-    ]));
-}
-function recordFromMeta(raw, company, projectId, expectedKind) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh returned a malformed tracker record", {
-            source: "Work Mesh", kind: expectedKind, company: company.slug, project_id: projectId,
-        });
-    }
-    const meta = raw;
-    if (meta.companyUid !== company.uid || meta.projectId !== projectId || meta.kind !== expectedKind || typeof meta.threadId !== "string" || !meta.threadId) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record identity did not match the requested company, project, and kind", {
-            source: "Work Mesh",
-            ...(typeof meta.threadId === "string" && meta.threadId ? { record_id: meta.threadId } : {}),
-            kind: expectedKind,
-            company: company.slug,
-            project_id: projectId,
-        });
-    }
-    const fields = fromMesh(meta);
-    const createdAt = typeof meta.createdAt === "string" ? meta.createdAt : "";
-    const updatedAt = typeof meta.lastActivityAt === "string" ? meta.lastActivityAt : createdAt;
-    const version = meta.version;
-    if (!Number.isSafeInteger(version) || version < 1 || !Number.isFinite(Date.parse(createdAt)) || !Number.isFinite(Date.parse(updatedAt))) {
-        return fail("tracker_mesh_response_invalid", "Work Mesh tracker record has invalid version or timestamps", {
-            source: "Work Mesh", record_id: meta.threadId, kind: expectedKind, company: company.slug, project_id: projectId,
-        });
-    }
-    const record = {
-        schema_version: "hq-lanes-tracker-record.v1",
-        kind: expectedKind,
-        id: meta.threadId,
-        company: company.slug,
-        project_id: projectId,
-        version: version,
-        created_at: createdAt,
-        updated_at: updatedAt,
-    };
-    for (const field of RECORD_FIELDS[expectedKind]) {
-        if (Object.hasOwn(fields, field))
-            record[field] = fields[field];
-    }
-    // hq-pro stores KPI and OKR status in the shared threadStatus metadata field.
-    if ((expectedKind === "kpi" || expectedKind === "okr") && !Object.hasOwn(record, "status") && Object.hasOwn(fields, "thread_status")) {
-        record.status = fields.thread_status;
-    }
-    if (expectedKind === "blocker" && !Object.hasOwn(record, "opened_at"))
-        record.opened_at = createdAt;
-    return record;
-}
-function identityMatches(record, kind, id, company, projectId) {
-    return record.kind === kind && record.id === id && record.company === company.slug && record.project_id === projectId;
-}
-function equalValue(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}
-export function createWorkMeshTrackerStore(options) {
-    const { company, projectId } = options;
-    if (!company.slug.trim() || !company.uid.trim())
-        fail("tracker_company_unresolved", "A resolved company slug and uid are required for Work Mesh tracker storage", {});
-    if (!projectId.trim())
-        fail("tracker_project_invalid", "A project id is required for Work Mesh tracker storage", {});
-    const now = options.now ?? (() => new Date());
-    const request = options.request ?? (async (endpoint, init) => {
-        const token = await requireToken({ interactive: false });
-        return meshJson(token, endpoint, init);
-    });
-    const requestJson = async (endpoint, init) => {
-        try {
-            const result = await request(endpoint, init);
-            if (!result || typeof result !== "object" || Array.isArray(result)) {
-                return fail("tracker_mesh_response_invalid", "Work Mesh returned an invalid tracker response", { endpoint });
-            }
-            return result;
-        }
-        catch (err) {
-            throw mapWorkMeshTrackerError(err);
-        }
-    };
-    const list = async (kind) => {
-        const records = [];
-        let cursor;
-        for (let page = 0; page < MAX_RECORD_PAGES; page += 1) {
-            const query = { companyUid: company.uid, projectId, kind, limit: "100", ...(cursor ? { cursor } : {}) };
-            const result = await requestJson(ROOT, { method: "GET", query });
-            if (!Array.isArray(result.threads))
-                return fail("tracker_mesh_response_invalid", "Work Mesh tracker list did not include a threads array", { kind, project_id: projectId });
-            for (const row of result.threads)
-                records.push(recordFromMeta(row, company, projectId, kind));
-            if (result.nextCursor === undefined)
-                return records.sort((a, b) => b.updated_at.localeCompare(a.updated_at) || a.id.localeCompare(b.id));
-            if (typeof result.nextCursor !== "string" || !result.nextCursor || result.nextCursor === cursor) {
-                return fail("tracker_mesh_response_invalid", "Work Mesh tracker list returned an invalid pagination cursor", { kind, project_id: projectId });
-            }
-            cursor = result.nextCursor;
-        }
-        return fail("tracker_mesh_response_incomplete", "Work Mesh tracker list exceeded its bounded page limit", { kind, project_id: projectId, max_pages: MAX_RECORD_PAGES });
-    };
-    const read = async (kind, id) => {
-        const record = (await list(kind)).find((candidate) => candidate.id === id);
-        if (record && !identityMatches(record, kind, id, company, projectId)) {
-            return fail("tracker_company_mismatch", "Work Mesh tracker record does not belong to the selected company and project", { kind, id, project_id: projectId });
-        }
-        return record ?? null;
-    };
-    return {
-        read,
-        list,
-        async create(input) {
-            if (input.company !== company.slug || input.project_id !== projectId) {
-                return fail("tracker_company_mismatch", "Tracker record company and project must match the resolved Work Mesh scope", { company: input.company, project_id: input.project_id });
-            }
-            const clientRecordId = input.id ?? (options.clientRecordId ?? randomUUID)();
-            const { id: _id, company: _company, project_id: _projectId, kind, ...fields } = input;
-            const result = await requestJson(ROOT, {
-                method: "POST",
-                body: { companyUid: company.uid, kind, projectId, clientRecordId, ...toMesh(fields) },
-            });
-            if (typeof result.threadId !== "string" || !result.threadId || !Number.isSafeInteger(result.version) || result.version < 1 || typeof result.createdAt !== "string" || !Number.isFinite(Date.parse(result.createdAt))) {
-                return fail("tracker_mesh_response_invalid", "Work Mesh did not return valid tracker creation metadata", { kind, project_id: projectId });
-            }
-            const createdAt = result.createdAt;
-            return {
-                ...input,
-                schema_version: "hq-lanes-tracker-record.v1",
-                kind,
-                id: result.threadId,
-                company: company.slug,
-                project_id: projectId,
-                version: result.version,
-                created_at: createdAt,
-                updated_at: typeof result.lastActivityAt === "string" ? result.lastActivityAt : createdAt,
-            };
-        },
-        async update(kind, id, expectedVersion, change, metadata) {
-            const current = await read(kind, id);
-            if (!current)
-                return fail("tracker_record_not_found", `Tracker ${kind} record ${id} was not found`, { kind, id, project_id: projectId });
-            if (current.version !== expectedVersion) {
-                return fail("tracker_version_conflict", `Tracker record version conflict: expected ${expectedVersion}, found ${current.version}`, { kind, id, expected: expectedVersion, actual: current.version });
-            }
-            const changed = change(current);
-            if (changed.id !== current.id || changed.kind !== current.kind || changed.company !== current.company || changed.project_id !== current.project_id || changed.created_at !== current.created_at) {
-                return fail("tracker_update_invalid", "Tracker update cannot change record identity", { kind, id });
-            }
-            const patch = Object.fromEntries(Object.entries(changed).filter(([key, value]) => !["schema_version", "kind", "id", "company", "project_id", "version", "created_at", "updated_at"].includes(key) && !equalValue(current[key], value)));
-            if (Object.keys(patch).length === 0)
-                return current;
-            const currentValues = Array.isArray(current.values) ? current.values : [];
-            const changedValues = Array.isArray(changed.values) ? changed.values : [];
-            const isKpiAppend = kind === "kpi" && changedValues.length === currentValues.length + 1 && currentValues.every((value, index) => equalValue(value, changedValues[index]));
-            const currentAcks = Array.isArray(current.acknowledgements) ? current.acknowledgements : [];
-            const changedAcks = Array.isArray(changed.acknowledgements) ? changed.acknowledgements : [];
-            const isAckAppend = kind === "directive" && changedAcks.length === currentAcks.length + 1 && currentAcks.every((value, index) => equalValue(value, changedAcks[index]));
-            let version;
-            let updatedAt = now().toISOString();
-            if (isKpiAppend) {
-                const value = changedValues.at(-1);
-                const response = await requestJson(`${ROOT}/${encodeURIComponent(id)}/events`, {
-                    method: "POST",
-                    body: { companyUid: company.uid, eventKind: "kpi_value", payload: toMesh(value) },
-                });
-                version = Number(response.version ?? current.version + 1);
-                if (typeof response.createdAt === "string")
-                    updatedAt = response.createdAt;
-            }
-            else if (isAckAppend) {
-                const ack = changedAcks.at(-1);
-                const response = await requestJson(`${ROOT}/${encodeURIComponent(id)}/events`, {
-                    method: "POST",
-                    body: { companyUid: company.uid, eventKind: "ack", payload: toMesh(ack) },
-                });
-                version = Number(response.version ?? current.version + 1);
-                if (typeof response.createdAt === "string")
-                    updatedAt = response.createdAt;
-            }
-            else {
-                const action = kind === "blocker" && current.resolved_at == null && changed.resolved_at != null
-                    ? "resolve"
-                    : ((kind === "kpi" || kind === "okr") && changed.status === "approved" && current.status !== "approved")
-                        ? "approve"
-                        : "update";
-                const result = await requestJson(`${ROOT}/${encodeURIComponent(id)}`, {
-                    method: "PATCH",
-                    body: { companyUid: company.uid, action, expectedVersion, ...(action === "approve" && metadata?.approvalQuestionId ? { approvalQuestionId: metadata.approvalQuestionId } : {}), ...toMesh(patch) },
-                });
-                version = Number(result.version);
-                if (typeof result.lastActivityAt === "string")
-                    updatedAt = result.lastActivityAt;
-            }
-            if (!Number.isSafeInteger(version) || version <= current.version) {
-                return fail("tracker_mesh_response_invalid", "Work Mesh tracker update returned an invalid version", { kind, id });
-            }
-            return { ...changed, schema_version: "hq-lanes-tracker-record.v1", version, created_at: current.created_at, updated_at: updatedAt };
-        },
-    };
-}
-//# sourceMappingURL=tracker-mesh.js.map