@work-graph/cli 0.2.0

package/vendor/src/analyticsPanelProjection.mjs

@@ -0,0 +1,212 @@
+import { readAnalyticsRecordJournal } from './analyticsRecordStore.mjs';
+import { attachRelatedWorkItemsToAnalyticsRecords } from './analyticsRecordWorkItems.mjs';
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+import { buildIntentGraphProjection, attachIntentGraphToAnalyticsRecords } from './intentGraphProjection.mjs';
+import { readIntentNodesFromRepo } from './intentNodeRuntime.mjs';
+
+export const ANALYTICS_PANEL_PROJECTION_SCHEMA = 'analytics-panel.projection.v1';
+export const ANALYTICS_RECORDS_API_SCHEMA = 'analytics-records.api.v1';
+export const DEFAULT_ANALYTICS_RECORDS_LIMIT = 50;
+export const ANALYTICS_RECORD_KIND_INTAKE = 'intake';
+export const ANALYTICS_RECORD_KIND_CLOSING = 'closing';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+/**
+ * Intake AN (prospective analysis) vs closing AN (epic post-mortem).
+ * Do not use feeds_epics or closing-analysis tag alone — intake may discuss or feed epics (AN-22, AN-25).
+ */
+export function inferAnalyticsRecordKind(record) {
+  if (!record || typeof record !== 'object') {
+    return ANALYTICS_RECORD_KIND_INTAKE;
+  }
+
+  const id = String(record.id ?? '').trim().toLowerCase();
+  const bodyPath = String(record.bodyPath ?? '').trim().toLowerCase();
+  const title = String(record.title ?? '').trim().toLowerCase();
+
+  if (
+    id.includes('closing-')
+    || bodyPath.includes('/closing-')
+    || bodyPath.includes('closing-epic')
+  ) {
+    return ANALYTICS_RECORD_KIND_CLOSING;
+  }
+
+  if (/^an-\d+:\s*closing\b/iu.test(title)) {
+    return ANALYTICS_RECORD_KIND_CLOSING;
+  }
+
+  return ANALYTICS_RECORD_KIND_INTAKE;
+}
+
+export function attachAnalyticsRecordKind(record) {
+  return {
+    ...record,
+    recordKind: inferAnalyticsRecordKind(record),
+  };
+}
+
+export function filterAnalyticsRecordsByKind(records, kind) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  const normalizedKind = String(kind ?? '').trim();
+  if (normalizedKind === '') {
+    return records;
+  }
+
+  return records.filter((record) => inferAnalyticsRecordKind(record) === normalizedKind);
+}
+
+function summarizeRecords(records) {
+  const byTopic = {};
+  const byStatus = {};
+  const byKind = {
+    [ANALYTICS_RECORD_KIND_INTAKE]: 0,
+    [ANALYTICS_RECORD_KIND_CLOSING]: 0,
+  };
+
+  for (const record of records) {
+    byTopic[record.topic] = (byTopic[record.topic] ?? 0) + 1;
+    byStatus[record.status] = (byStatus[record.status] ?? 0) + 1;
+    const kind = inferAnalyticsRecordKind(record);
+    byKind[kind] = (byKind[kind] ?? 0) + 1;
+  }
+
+  return {
+    total: records.length,
+    byTopic,
+    byStatus,
+    byKind,
+  };
+}
+
+export function assignAnalyticsRecordKeys(records) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  if (records.length === 0) {
+    return [];
+  }
+
+  const sorted = [...records].sort((left, right) => {
+    const createdCmp = String(left.createdAt ?? '').localeCompare(
+      String(right.createdAt ?? ''),
+      'en',
+      { sensitivity: 'variant' },
+    );
+    if (createdCmp !== 0) {
+      return createdCmp;
+    }
+
+    return compareText(left.id, right.id);
+  });
+
+  const ordinalById = new Map();
+  sorted.forEach((record, index) => {
+    ordinalById.set(record.id, index + 1);
+  });
+
+  return records.map((record) => ({
+    ...record,
+    key: String(record.key ?? '').trim() || `AN-${ordinalById.get(record.id)}`,
+  }));
+}
+
+export function sortAnalyticsRecordsByRecencyDesc(records) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  return [...records].sort((left, right) => {
+    const createdCmp = String(right.createdAt ?? '').localeCompare(
+      String(left.createdAt ?? ''),
+      'en',
+      { sensitivity: 'variant' },
+    );
+    if (createdCmp !== 0) {
+      return createdCmp;
+    }
+
+    return compareText(right.id, left.id);
+  });
+}
+
+export function filterAnalyticsRecords(records, options = {}) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  let filtered = records;
+  const topic = String(options.topic ?? '').trim();
+  if (topic !== '') {
+    filtered = filtered.filter((record) => record.topic === topic);
+  }
+
+  const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : null;
+  const truncated = limit !== null && filtered.length > limit;
+  if (limit !== null) {
+    filtered = filtered.slice(0, limit);
+  }
+
+  return {
+    records: filtered,
+    truncated,
+    limit: limit ?? filtered.length,
+    topic: topic || null,
+  };
+}
+
+export function buildAnalyticsPanelProjectionFromRecords(records, options = {}) {
+  const keyedRecords = assignAnalyticsRecordKeys(records).map((record) => attachAnalyticsRecordKind(record));
+  const summary = summarizeRecords(keyedRecords);
+  const orderedRecords = sortAnalyticsRecordsByRecencyDesc(keyedRecords);
+
+  return {
+    schema: ANALYTICS_PANEL_PROJECTION_SCHEMA,
+    readOnly: true,
+    source: options.source ?? 'analytics-records-journal',
+    summary,
+    records: orderedRecords,
+    filters: {
+      topics: Object.keys(summary.byTopic).sort(),
+      statuses: Object.keys(summary.byStatus).sort(),
+    },
+  };
+}
+
+export async function buildAnalyticsRecordsApiResponse(options = {}) {
+  const journal = await readAnalyticsRecordJournal(options);
+  const keyedRecords = assignAnalyticsRecordKeys(journal.records).map((record) => attachAnalyticsRecordKind(record));
+  const orderedRecords = sortAnalyticsRecordsByRecencyDesc(keyedRecords);
+  const filtered = filterAnalyticsRecords(orderedRecords, {
+    topic: options.topic,
+    limit: options.limit ?? DEFAULT_ANALYTICS_RECORDS_LIMIT,
+  });
+
+  return {
+    schema: ANALYTICS_RECORDS_API_SCHEMA,
+    count: filtered.records.length,
+    truncated: filtered.truncated,
+    topic: filtered.topic,
+    limit: filtered.limit,
+    records: filtered.records,
+  };
+}
+
+export async function buildAnalyticsPanelProjection(options = {}) {
+  const journal = await readAnalyticsRecordJournal(options);
+  const projection = buildAnalyticsPanelProjectionFromRecords(journal.records, options);
+  const workItems = await readWorkItemsFromRepo(options);
+  const intentNodes = await readIntentNodesFromRepo(options);
+  const intentGraph = buildIntentGraphProjection(intentNodes, workItems, options);
+  const withWorkItems = attachRelatedWorkItemsToAnalyticsRecords(projection.records, workItems);
+  return {
+    ...projection,
+    intentGraphSchema: intentGraph.schema,
+    records: attachIntentGraphToAnalyticsRecords(withWorkItems, intentGraph),
+  };
+}

package/vendor/src/analyticsRecordStore.mjs

@@ -0,0 +1,165 @@
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const ANALYTICS_RECORD_SCHEMA = 'analytics-record.v1';
+export const ANALYTICS_RECORD_JOURNAL_SCHEMA = 'analytics-record.journal.v1';
+export const ANALYTICS_RECORD_JOURNAL_READ_SCHEMA = 'analytics-record.journal.read.v1';
+export const ANALYTICS_RECORD_JOURNAL_APPEND_SCHEMA = 'analytics-record.journal.append.v1';
+export const DEFAULT_ANALYTICS_RECORD_JOURNAL_PATH = 'work/analytics-records.jsonl';
+
+function stableAnalyticsId(slug) {
+  const normalized = String(slug ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/^-+|-+$/gu, '')
+    .slice(0, 48);
+  return `analytics:${normalized || 'record'}`;
+}
+
+export function buildAnalyticsRecord(input, options = {}) {
+  if (!input || typeof input !== 'object') {
+    throw new TypeError('input is required');
+  }
+
+  const title = String(input.title ?? '').trim();
+  const query = String(input.query ?? '').trim();
+  if (!title) {
+    throw new TypeError('title is required');
+  }
+  if (!query) {
+    throw new TypeError('query is required');
+  }
+
+  const slug = input.slug ?? title;
+  const createdAt = input.createdAt ?? options.appendedAt ?? new Date().toISOString();
+
+  return {
+    schema: ANALYTICS_RECORD_SCHEMA,
+    id: input.id ?? stableAnalyticsId(slug),
+    title,
+    query,
+    topic: String(input.topic ?? 'general').trim(),
+    status: input.status ?? 'published',
+    tags: [...(input.tags ?? [])].map(String).sort(compareText),
+    relatedFiles: [...(input.relatedFiles ?? [])].map(String).sort(compareText),
+    body: input.body ?? '',
+    bodyPath: input.bodyPath ?? null,
+    createdAt,
+    updatedAt: input.updatedAt ?? createdAt,
+    author: input.author ?? 'operator',
+    ...(String(input.key ?? '').trim() !== '' ? { key: String(input.key).trim() } : {}),
+  };
+}
+
+async function resolveRecordBody(record, options = {}) {
+  const bodyPath = String(record.bodyPath ?? '').trim();
+  if (!bodyPath) {
+    return String(record.body ?? '');
+  }
+
+  const absolutePath = resolve(options.cwd ?? process.cwd(), bodyPath);
+  try {
+    return await readFile(absolutePath, 'utf8');
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return String(record.body ?? '');
+    }
+
+    throw error;
+  }
+}
+
+export async function hydrateAnalyticsRecords(records, options = {}) {
+  return Promise.all(records.map(async (record) => ({
+    ...record,
+    body: await resolveRecordBody(record, options),
+  })));
+}
+
+export function buildAnalyticsJournalEntry(record, options = {}) {
+  const appendedAt = options.appendedAt ?? new Date().toISOString();
+  const normalized = buildAnalyticsRecord(record, { appendedAt });
+
+  return {
+    schema: ANALYTICS_RECORD_JOURNAL_SCHEMA,
+    appendedAt,
+    record: normalized,
+  };
+}
+
+export async function readAnalyticsRecordJournal(options = {}) {
+  const journalPath = resolve(options.cwd ?? process.cwd(), options.journalPath ?? DEFAULT_ANALYTICS_RECORD_JOURNAL_PATH);
+
+  let text = '';
+  try {
+    text = await readFile(journalPath, 'utf8');
+  } catch (error) {
+    if (error && typeof error === 'object' && error.code === 'ENOENT') {
+      return {
+        schema: ANALYTICS_RECORD_JOURNAL_READ_SCHEMA,
+        journalPath,
+        entryCount: 0,
+        entries: [],
+        records: [],
+      };
+    }
+
+    throw error;
+  }
+
+  const entries = text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line, index) => {
+      const parsed = JSON.parse(line);
+      if (parsed.schema !== ANALYTICS_RECORD_JOURNAL_SCHEMA) {
+        throw new Error(`invalid analytics journal entry at line ${index + 1}: expected ${ANALYTICS_RECORD_JOURNAL_SCHEMA}`);
+      }
+
+      return parsed;
+    });
+
+  const latestById = new Map();
+  for (const entry of entries) {
+    latestById.set(entry.record.id, entry.record);
+  }
+
+  const records = [...latestById.values()].sort((left, right) => compareText(left.id, right.id));
+  const hydrated = await hydrateAnalyticsRecords(records, options);
+
+  return {
+    schema: ANALYTICS_RECORD_JOURNAL_READ_SCHEMA,
+    journalPath,
+    entryCount: entries.length,
+    entries,
+    records: hydrated,
+  };
+}
+
+export async function appendAnalyticsRecordJournal(records, journalPath, options = {}) {
+  if (!Array.isArray(records) || records.length === 0) {
+    throw new TypeError('records must be a non-empty array');
+  }
+
+  const resolvedPath = resolve(options.cwd ?? process.cwd(), journalPath ?? DEFAULT_ANALYTICS_RECORD_JOURNAL_PATH);
+  const appendedAt = options.appendedAt ?? new Date().toISOString();
+  const entries = records.map((record) => buildAnalyticsJournalEntry(record, { appendedAt }));
+
+  if (options.dryRun !== true) {
+    await mkdir(dirname(resolvedPath), { recursive: true });
+    for (const entry of entries) {
+      await appendFile(resolvedPath, `${JSON.stringify(entry)}\n`, 'utf8');
+    }
+  }
+
+  return {
+    schema: ANALYTICS_RECORD_JOURNAL_APPEND_SCHEMA,
+    journalPath: resolvedPath,
+    appended: entries.length,
+    entries,
+    records: await hydrateAnalyticsRecords(entries.map((entry) => entry.record), options),
+  };
+}

package/vendor/src/analyticsRecordWorkItems.mjs

@@ -0,0 +1,104 @@
+function normalizeLines(value) {
+  if (Array.isArray(value)) {
+    return value.map((line) => String(line).trim()).filter(Boolean);
+  }
+
+  return String(value ?? '')
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function workItemTextHaystack(item) {
+  return [
+    ...normalizeLines(item.basis),
+    ...normalizeLines(item.vector),
+    ...normalizeLines(item.goal),
+    ...normalizeLines(item.analysis),
+    ...normalizeLines(item.decision),
+    ...normalizeLines(item.checks),
+    ...(item.targetFiles ?? []),
+    item.title,
+    item.id,
+  ].join('\n');
+}
+
+export function summarizeWorkItemForAnalyticsRecord(item) {
+  return {
+    id: item.id,
+    title: item.title ?? item.id,
+    status: item.status ?? '',
+    department: item.department ?? '',
+    ownerRole: item.ownerRole ?? '',
+  };
+}
+
+export function workItemMatchesAnalyticsRecord(record, item) {
+  if (!record || !item) {
+    return false;
+  }
+
+  const recordId = String(record.id ?? '').trim();
+  const recordKey = String(record.key ?? '').trim();
+  const bodyPath = String(record.bodyPath ?? '').trim();
+  const slug = recordId.startsWith('analytics:') ? recordId.slice('analytics:'.length) : '';
+  const labels = item.labels ?? {};
+
+  if (recordId !== '' && String(labels['intake.source_ref'] ?? '').trim() === recordId) {
+    return true;
+  }
+
+  if (recordKey !== '' && String(labels['intake.analytics_key'] ?? '').trim() === recordKey) {
+    return true;
+  }
+
+  const haystack = workItemTextHaystack(item);
+  if (recordId !== '' && haystack.includes(recordId)) {
+    return true;
+  }
+
+  if (recordKey !== '' && (haystack.includes(`(${recordKey})`) || haystack.includes(`${recordKey},`))) {
+    return true;
+  }
+
+  if (bodyPath !== '' && haystack.includes(bodyPath)) {
+    return true;
+  }
+
+  if (slug !== '' && haystack.includes(`analytics:${slug}`)) {
+    return true;
+  }
+
+  const questionId = String(labels['intent.question_id'] ?? '').trim();
+  const decisionId = String(labels['intent.decision_id'] ?? '').trim();
+  if (recordKey === 'AN-3' && questionId === 'iq:intent-graph-storage') {
+    return true;
+  }
+  if (recordId !== '' && decisionId !== '' && recordId.includes('intent-graph-storage')) {
+    return true;
+  }
+
+  return false;
+}
+
+export function findWorkItemsForAnalyticsRecord(record, workItems) {
+  if (!Array.isArray(workItems)) {
+    return [];
+  }
+
+  return workItems
+    .filter((item) => workItemMatchesAnalyticsRecord(record, item))
+    .map((item) => summarizeWorkItemForAnalyticsRecord(item))
+    .sort((left, right) => left.id.localeCompare(right.id, 'en', { sensitivity: 'variant' }));
+}
+
+export function attachRelatedWorkItemsToAnalyticsRecords(records, workItems) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  return records.map((record) => ({
+    ...record,
+    relatedWorkItems: findWorkItemsForAnalyticsRecord(record, workItems),
+  }));
+}