@work-graph/cli 0.2.0

package/vendor/src/intentTreeWorkItems.mjs

@@ -0,0 +1,227 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { resolveIntentPathFromIndex } from './intentHierarchy.mjs';
+import { buildIntentIndexStep } from './intentTreeMigration.mjs';
+import { intentPathForNewWorkItem } from './bvcNewWritePolicy.mjs';
+import { readBvcTextFile, resolveBvcReadablePath } from './bvcFileFormat.mjs';
+import { parseWorkItems } from './workGraphRuntime.mjs';
+import {
+  findWorkItemAtomSpan,
+  patchWorkItemInBacklogText,
+} from './workGraphBacklogPersist.mjs';
+
+const DEFAULT_INTENT_INDEX_PATH = 'intent/index.bvc';
+
+export async function readIntentWorkItemTexts(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const indexPath = resolveBvcReadablePath(options.intentIndexPath ?? DEFAULT_INTENT_INDEX_PATH, cwd);
+  const indexText = options.indexText ?? await readBvcTextFile(options.intentIndexPath ?? DEFAULT_INTENT_INDEX_PATH, { cwd });
+  const entries = parseIntentIndexEntries(indexText);
+  const texts = [];
+
+  for (const entry of entries) {
+    texts.push(await readBvcTextFile(entry.path, { cwd }));
+  }
+
+  return {
+    indexPath,
+    indexText,
+    entries,
+    texts,
+  };
+}
+
+export async function readWorkItemsFromIntentTree(options = {}) {
+  const { texts } = await readIntentWorkItemTexts(options);
+  return parseWorkItems(texts.join('\n'));
+}
+
+export async function readWorkItemsFromRepo(options = {}) {
+  if (options.backlogText !== undefined) {
+    return parseWorkItems(options.backlogText);
+  }
+
+  if (options.backlogPath) {
+    const backlogPath = resolveBvcReadablePath(options.backlogPath, options.cwd ?? process.cwd());
+    const backlogText = await readBvcTextFile(options.backlogPath, { cwd: options.cwd });
+    return parseWorkItems(backlogText);
+  }
+
+  return readWorkItemsFromIntentTree(options);
+}
+
+export async function readWorkItemAtomFromRepo(workId, options = {}) {
+  const normalizedWorkId = String(workId ?? '').trim();
+  if (normalizedWorkId === '') {
+    throw new TypeError('workId is required');
+  }
+
+  if (options.backlogText !== undefined || options.backlogPath) {
+    const cwd = options.cwd ?? process.cwd();
+    const backlogPath = options.backlogPath
+      ? resolveBvcReadablePath(options.backlogPath, cwd)
+      : null;
+    const text = options.backlogText ?? await readBvcTextFile(options.backlogPath, { cwd });
+    const span = findWorkItemAtomSpan(text, normalizedWorkId);
+    if (!span) {
+      throw new Error(`work item atom not found: ${normalizedWorkId}`);
+    }
+    return {
+      mode: 'backlog',
+      path: backlogPath,
+      text,
+      atomText: span.fullMatch,
+      span,
+    };
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const indexPath = options.intentIndexPath ?? DEFAULT_INTENT_INDEX_PATH;
+  const indexText = options.indexText ?? await readBvcTextFile(indexPath, { cwd });
+  const relativePath = resolveIntentPathFromIndex(indexText, normalizedWorkId);
+  if (!relativePath) {
+    throw new Error(`intent path not found for work item: ${normalizedWorkId}`);
+  }
+
+  const path = resolveBvcReadablePath(relativePath, cwd);
+  const text = await readBvcTextFile(relativePath, { cwd });
+  const span = findWorkItemAtomSpan(text, normalizedWorkId);
+  if (!span) {
+    throw new Error(`work item atom not found in ${relativePath}: ${normalizedWorkId}`);
+  }
+
+  return {
+    mode: 'intent',
+    path,
+    relativePath,
+    indexPath: resolveBvcReadablePath(indexPath, cwd),
+    indexText,
+    text,
+    atomText: span.fullMatch,
+    span,
+  };
+}
+
+export async function persistWorkItemUpdateToRepo(options = {}) {
+  const item = options.item;
+  if (!item?.id) {
+    throw new TypeError('item.id is required');
+  }
+
+  if (options.backlogPath || options.backlogText !== undefined) {
+    const cwd = options.cwd ?? process.cwd();
+    const backlogPath = options.backlogPath
+      ? resolveBvcReadablePath(options.backlogPath, cwd)
+      : null;
+    const sourceText = options.backlogText ?? await readBvcTextFile(options.backlogPath, { cwd });
+    const newText = patchWorkItemInBacklogText(sourceText, item);
+    if (options.persistBacklog !== false && backlogPath) {
+      await writeTextAtomically(backlogPath, newText);
+    }
+    return {
+      path: backlogPath,
+      workId: item.id,
+      status: item.status,
+      mode: 'backlog',
+      persisted: options.persistBacklog !== false && Boolean(backlogPath),
+    };
+  }
+
+  const source = await readWorkItemAtomFromRepo(item.id, options);
+  const newText = patchWorkItemInBacklogText(source.text, item);
+  if (options.persistIntent !== false) {
+    await writeTextAtomically(source.path, newText);
+  }
+  return {
+    path: source.relativePath ?? source.path,
+    workId: item.id,
+    status: item.status,
+    mode: 'intent',
+    persisted: options.persistIntent !== false,
+  };
+}
+
+export async function persistWorkItemUpdatesToRepo(items, options = {}) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return [];
+  }
+
+  const results = [];
+  for (const item of items) {
+    results.push(await persistWorkItemUpdateToRepo({ ...options, item }));
+  }
+  return results;
+}
+
+export async function appendWorkItemAtomToIntentTree(atomText, options = {}) {
+  const atom = String(atomText ?? '').trim();
+  if (atom === '') {
+    throw new TypeError('atomText must be a non-empty string');
+  }
+
+  const [item] = parseWorkItems(atom);
+  if (!item?.id) {
+    throw new Error('atomText must contain a WorkItem');
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const indexPath = resolveBvcReadablePath(options.intentIndexPath ?? DEFAULT_INTENT_INDEX_PATH, cwd);
+  let indexText = '';
+  let entries = [];
+  try {
+    indexText = await readBvcTextFile(options.intentIndexPath ?? DEFAULT_INTENT_INDEX_PATH, { cwd });
+    entries = parseIntentIndexEntries(indexText);
+  } catch (error) {
+    if (!error || typeof error !== 'object' || error.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  if (entries.some((entry) => entry.id === item.id)) {
+    throw new Error(`work.id already exists: ${item.id}`);
+  }
+
+  const path = options.path ?? intentPathForNewWorkItem(item);
+  const nextEntries = [...entries, { id: item.id, path }]
+    .sort((left, right) => compareText(left.id, right.id));
+  const absolutePath = resolve(cwd, path);
+
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeTextAtomically(absolutePath, `${atom}\n`);
+  await mkdir(dirname(indexPath), { recursive: true });
+  await writeTextAtomically(indexPath, buildIntentIndexStep(nextEntries.map((entry) => ({
+    id: entry.id,
+    path: entry.path,
+  }))));
+
+  return {
+    workId: item.id,
+    path,
+    indexPath,
+  };
+}
+
+export function parseIntentIndexEntries(indexText) {
+  if (typeof indexText !== 'string') {
+    throw new TypeError('indexText must be a string');
+  }
+
+  return [...indexText.matchAll(/^\s*-\s*([^:\s]+):\s*(\S+)\s*$/gmu)]
+    .map((match) => ({ id: match[1], path: match[2] }))
+    .sort((left, right) => compareText(left.id, right.id));
+}
+
+function intentPathForItem(item) {
+  return intentPathForNewWorkItem(item);
+}
+
+async function writeTextAtomically(path, text) {
+  const tempPath = `${path}.tmp`;
+  await writeFile(tempPath, text, 'utf8');
+  await rename(tempPath, path);
+}
+
+function compareText(left, right) {
+  return String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+}

package/vendor/src/kanbanBoardProjection.mjs

@@ -0,0 +1,58 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const KANBAN_BOARD_PROJECTION_SCHEMA = 'workgraph.kanban-board-projection.v1';
+
+export const KANBAN_BOARD_COLUMNS = [
+  { id: 'backlog', title: 'Бэклог', statuses: ['backlog'] },
+  { id: 'ready', title: 'Ready', statuses: ['ready'] },
+  { id: 'in_progress', title: 'В работе', statuses: ['claimed', 'doing', 'in_progress', 'verify', 'blocked'] },
+  { id: 'done', title: 'Завершено', statuses: ['done', 'verified'] },
+];
+
+function summarizeItem(item) {
+  return {
+    workId: item.id,
+    title: item.title,
+    status: item.status,
+    department: item.department ?? '',
+    priority: item.priority ?? '',
+    ownerRole: item.ownerRole ?? '',
+  };
+}
+
+export function buildKanbanBoardProjection(items, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const sortedItems = [...items].sort((left, right) => compareText(left.id, right.id));
+  const statusCounts = Object.create(null);
+
+  for (const item of sortedItems) {
+    statusCounts[item.status] = (statusCounts[item.status] ?? 0) + 1;
+  }
+
+  const columns = KANBAN_BOARD_COLUMNS.map((column) => {
+    const columnItems = sortedItems.filter((item) => column.statuses.includes(item.status));
+    return {
+      id: column.id,
+      title: column.title,
+      statuses: [...column.statuses],
+      count: columnItems.length,
+      workIds: columnItems.map((item) => item.id),
+      items: options.includeItems === true ? columnItems.map(summarizeItem) : undefined,
+    };
+  });
+
+  const columnCounts = Object.fromEntries(columns.map((column) => [column.id, column.count]));
+
+  return {
+    schema: KANBAN_BOARD_PROJECTION_SCHEMA,
+    readOnly: true,
+    dragEnabled: false,
+    itemCount: sortedItems.length,
+    statusCounts,
+    columnCounts,
+    columns,
+  };
+}

package/vendor/src/languageAdapterRegistry.mjs

@@ -0,0 +1,180 @@
+import { extractGoFacts, goAdapter } from './languageAdapters/goAdapter.mjs';
+import { extractJsonYamlFacts, jsonYamlAdapter } from './languageAdapters/jsonYamlAdapter.mjs';
+import { extractJsTsFacts, jsTsAdapter } from './languageAdapters/jsTsAdapter.mjs';
+import { extractOnebaseOsFacts, onebaseOsAdapter } from './languageAdapters/onebaseOsAdapter.mjs';
+import { extractPlaintextFacts, plaintextAdapter } from './languageAdapters/plaintextAdapter.mjs';
+import { extensionFromPath } from './languageAdapters/shared.mjs';
+import { extractStepFacts, stepAdapter } from './languageAdapters/stepAdapter.mjs';
+
+export const LANGUAGE_ADAPTER_REGISTRY_SCHEMA = 'workgraph.language-adapter-registry.v1';
+
+const ADAPTERS = [
+  stepAdapter,
+  jsonYamlAdapter,
+  jsTsAdapter,
+  goAdapter,
+  onebaseOsAdapter,
+];
+
+const EXTRACTORS = new Map([
+  [stepAdapter.id, extractStepFacts],
+  [jsonYamlAdapter.id, extractJsonYamlFacts],
+  [jsTsAdapter.id, extractJsTsFacts],
+  [goAdapter.id, extractGoFacts],
+  [onebaseOsAdapter.id, extractOnebaseOsFacts],
+  [plaintextAdapter.id, extractPlaintextFacts],
+]);
+
+const ADAPTER_BY_ID = new Map([
+  ...ADAPTERS.map((adapter) => [adapter.id, adapter]),
+  [plaintextAdapter.id, plaintextAdapter],
+]);
+
+export function buildLanguageAdapterRegistry() {
+  return {
+    schema: LANGUAGE_ADAPTER_REGISTRY_SCHEMA,
+    adapters: [...ADAPTERS, plaintextAdapter].map(toRegistryRecord),
+    fallbackAdapterId: plaintextAdapter.id,
+  };
+}
+
+export function resolveLanguageAdapter(input = {}) {
+  const filePath = String(input.filePath ?? '');
+  const languageId = input.languageId ? String(input.languageId) : null;
+  const extension = String(input.extension ?? extensionFromPath(filePath)).toLowerCase();
+
+  if (languageId) {
+    const byLanguage = ADAPTERS.find((adapter) => adapter.languageId === languageId);
+    if (byLanguage) {
+      return {
+        adapter: byLanguage,
+        match: 'languageId',
+        extension,
+      };
+    }
+  }
+
+  for (const adapter of ADAPTERS) {
+    if (adapter.extensions.includes(extension)) {
+      return {
+        adapter,
+        match: 'extension',
+        extension,
+      };
+    }
+  }
+
+  return {
+    adapter: plaintextAdapter,
+    match: 'fallback',
+    extension,
+  };
+}
+
+export function getAdapterCapabilities(input = {}) {
+  const resolved = resolveLanguageAdapter(input);
+  return {
+    adapterId: resolved.adapter.id,
+    languageId: resolved.adapter.languageId,
+    extension: resolved.extension,
+    match: resolved.match,
+    capabilities: { ...resolved.adapter.capabilities },
+    confidence: resolved.adapter.confidence,
+    fallback: resolved.adapter.fallback,
+  };
+}
+
+export function extractFileFacts(filePath, content, options = {}) {
+  const resolved = resolveLanguageAdapter({
+    filePath,
+    extension: options.extension,
+    languageId: options.languageId,
+  });
+  const extractor = EXTRACTORS.get(resolved.adapter.id) ?? extractPlaintextFacts;
+  const context = {
+    filePath,
+    extension: resolved.extension,
+  };
+
+  try {
+    return extractor(content, context);
+  } catch (error) {
+    const fallback = extractPlaintextFacts(content, context);
+    fallback.status = 'degraded';
+    fallback.confidence = 'low';
+    fallback.adapterId = plaintextAdapter.id;
+    fallback.languageId = plaintextAdapter.languageId;
+    fallback.diagnostics = [
+      ...(fallback.diagnostics ?? []),
+      error instanceof Error ? error.message : String(error),
+    ];
+    return fallback;
+  }
+}
+
+export function extractFileFactsBatch(entries, options = {}) {
+  const facts = (entries ?? []).map((entry) => extractFileFacts(entry.filePath, entry.content, options));
+  return {
+    schema: 'workgraph.language-file-facts.batch.v1',
+    facts,
+    summary: {
+      total: facts.length,
+      degraded: facts.filter((fact) => fact.status === 'degraded').length,
+      languages: [...new Set(facts.map((fact) => fact.languageId))].sort(),
+    },
+  };
+}
+
+export function buildTargetFileFactsProjection(readResult) {
+  const entries = (readResult?.files ?? [])
+    .filter((entry) => entry.ok)
+    .map((entry) => ({ filePath: entry.path, content: entry.content }));
+
+  return extractFileFactsBatch(entries);
+}
+
+export function formatLanguageFileFactsForPrompt(batch) {
+  if (!batch?.facts?.length) {
+    return '';
+  }
+
+  return batch.facts.map((fact) => {
+    const symbolNames = fact.symbols.slice(0, 8).map((symbol) => symbol.name).join(', ');
+    const importNames = fact.imports.slice(0, 6).map((entry) => entry.module).join(', ');
+    const domainSummary = Object.entries(fact.domainMetadata ?? {})
+      .filter(([, value]) => value !== null && value !== undefined && value !== '')
+      .slice(0, 6)
+      .map(([key, value]) => `${key}=${Array.isArray(value) ? value.join('|') : value}`)
+      .join('; ');
+
+    return [
+      `# facts:${fact.filePath}`,
+      `adapter=${fact.adapterId} language=${fact.languageId} status=${fact.status} confidence=${fact.confidence}`,
+      symbolNames ? `symbols: ${symbolNames}` : '',
+      importNames ? `imports: ${importNames}` : '',
+      domainSummary ? `domain: ${domainSummary}` : '',
+    ].filter(Boolean).join('\n');
+  }).join('\n\n');
+}
+
+function toRegistryRecord(adapter) {
+  return {
+    id: adapter.id,
+    languageId: adapter.languageId,
+    extensions: [...adapter.extensions],
+    artifactProfiles: [...adapter.artifactProfiles],
+    capabilities: { ...adapter.capabilities },
+    confidence: adapter.confidence,
+    fallback: adapter.fallback,
+    owner: adapter.owner,
+  };
+}
+
+export {
+  goAdapter,
+  jsonYamlAdapter,
+  jsTsAdapter,
+  onebaseOsAdapter,
+  plaintextAdapter,
+  stepAdapter,
+};

package/vendor/src/languageAdapters/goAdapter.mjs

@@ -0,0 +1,62 @@
+import { buildFileFactsEnvelope, createCapabilities } from './shared.mjs';
+
+export const goAdapter = {
+  id: 'go-v1',
+  languageId: 'go',
+  extensions: ['.go'],
+  artifactProfiles: ['go-package'],
+  capabilities: createCapabilities({
+    syntax: 'structured',
+    symbols: true,
+    imports: true,
+    tests: true,
+    semanticChunks: true,
+    verificationHints: true,
+  }),
+  confidence: 'medium',
+  fallback: 'plaintext-v1',
+  owner: 'work-graph',
+};
+
+const PACKAGE_PATTERN = /^package\s+([\w]+)/mu;
+const FUNC_PATTERN = /^func\s+(?:\(\s*[\w*\s]+\s+\*?[\w]+\s*\)\s+)?([\w]+)\s*\(/gmu;
+
+export function extractGoFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const text = String(content);
+  const packageName = text.match(PACKAGE_PATTERN)?.[1] ?? null;
+  const imports = [];
+
+  for (const match of text.matchAll(/^import\s+"([^"]+)"/gmu)) {
+    imports.push({ module: match[1] });
+  }
+
+  for (const match of text.matchAll(/^import\s+\([\s\S]*?\)/gmu)) {
+    for (const inner of match[0].matchAll(/"([^"]+)"/gu)) {
+      imports.push({ module: inner[1] });
+    }
+  }
+
+  const symbols = [...text.matchAll(FUNC_PATTERN)].map((match) => ({
+    kind: 'function',
+    name: match[1],
+  }));
+
+  const testHints = filePath.endsWith('_test.go')
+    ? [{ kind: 'go-test', commandHint: 'go test ./...' }]
+    : symbols.length > 0
+      ? [{ kind: 'go-package', commandHint: 'go test ./...' }]
+      : [];
+
+  return buildFileFactsEnvelope(goAdapter, filePath, {
+    imports,
+    symbols,
+    testHints,
+    domainMetadata: packageName ? { package: packageName } : {},
+    chunks: symbols.slice(0, 12).map((symbol) => ({
+      ref: `func:${symbol.name}`,
+      kind: 'function',
+      text: symbol.name,
+    })),
+  });
+}

package/vendor/src/languageAdapters/jsTsAdapter.mjs

@@ -0,0 +1,60 @@
+import { buildFileFactsEnvelope, createCapabilities } from './shared.mjs';
+
+export const jsTsAdapter = {
+  id: 'js-ts-v1',
+  languageId: 'typescript',
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+  artifactProfiles: ['javascript-module'],
+  capabilities: createCapabilities({
+    syntax: 'structured',
+    symbols: true,
+    imports: true,
+    tests: true,
+    semanticChunks: true,
+  }),
+  confidence: 'medium',
+  fallback: 'plaintext-v1',
+  owner: 'work-graph',
+};
+
+const IMPORT_PATTERN = /^\s*import\s+(?:type\s+)?(?:[\w*{}\s,$]+\s+from\s+)?['"]([^'"]+)['"]/gmu;
+const EXPORT_PATTERN = /^\s*export\s+(?:async\s+)?(?:function|class|const|let|var|type|interface)\s+([\w$]+)/gmu;
+const FUNCTION_PATTERN = /^\s*(?:export\s+)?(?:async\s+)?function\s+([\w$]+)/gmu;
+const TEST_HINT_PATTERN = /\.(?:test|spec)\.(?:js|mjs|cjs|ts|tsx)$/iu;
+
+export function extractJsTsFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const text = String(content);
+  const imports = [...text.matchAll(IMPORT_PATTERN)].map((match) => ({ module: match[1] }));
+  const symbols = [];
+  const seen = new Set();
+
+  for (const pattern of [EXPORT_PATTERN, FUNCTION_PATTERN]) {
+    for (const match of text.matchAll(pattern)) {
+      const name = match[1];
+      if (seen.has(name)) {
+        continue;
+      }
+
+      seen.add(name);
+      symbols.push({ kind: 'declaration', name });
+    }
+  }
+
+  const testHints = TEST_HINT_PATTERN.test(filePath)
+    ? [{ kind: 'test-file', commandHint: 'npm run test:deterministic' }]
+    : text.includes('describe(') || text.includes('it(')
+      ? [{ kind: 'test-suite', commandHint: 'npm run test:deterministic' }]
+      : [];
+
+  return buildFileFactsEnvelope(jsTsAdapter, filePath, {
+    imports,
+    symbols,
+    testHints,
+    chunks: symbols.slice(0, 12).map((symbol) => ({
+      ref: `symbol:${symbol.name}`,
+      kind: 'declaration',
+      text: symbol.name,
+    })),
+  });
+}

package/vendor/src/languageAdapters/jsonYamlAdapter.mjs

@@ -0,0 +1,103 @@
+import { basenameFromPath, buildFileFactsEnvelope, createCapabilities } from './shared.mjs';
+
+export const jsonYamlAdapter = {
+  id: 'json-yaml-v1',
+  languageId: 'yaml',
+  extensions: ['.json', '.yaml', '.yml'],
+  artifactProfiles: ['structured-metadata', 'onebase-yaml'],
+  capabilities: createCapabilities({
+    syntax: 'structured',
+    symbols: true,
+    domainMetadata: true,
+    semanticChunks: true,
+  }),
+  confidence: 'medium',
+  fallback: 'plaintext-v1',
+  owner: 'work-graph',
+};
+
+export function extractJsonYamlFacts(content, context = {}) {
+  const filePath = context.filePath ?? '';
+  const extension = context.extension ?? '';
+  const text = String(content);
+  const domainMetadata = inferOnebaseYamlMetadata(filePath, text);
+  const symbols = [];
+
+  if (domainMetadata.name) {
+    symbols.push({
+      kind: 'artifact',
+      name: domainMetadata.name,
+      profile: domainMetadata.artifactKind ?? 'yaml',
+    });
+  }
+
+  for (const field of domainMetadata.fields ?? []) {
+    symbols.push({ kind: 'field', name: field.name, type: field.type ?? 'unknown' });
+  }
+
+  if (extension === '.json') {
+    try {
+      const parsed = JSON.parse(text);
+      domainMetadata.jsonKeys = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? Object.keys(parsed).sort()
+        : [];
+    } catch (error) {
+      return buildFileFactsEnvelope(jsonYamlAdapter, filePath, {
+        symbols,
+        domainMetadata,
+        diagnostics: [error instanceof Error ? error.message : String(error)],
+        chunks: [{ ref: 'json:invalid', kind: 'json', text: text.slice(0, 500) }],
+      }, { status: 'degraded', confidence: 'low' });
+    }
+  }
+
+  return buildFileFactsEnvelope(jsonYamlAdapter, filePath, {
+    symbols,
+    domainMetadata,
+    chunks: [{
+      ref: 'metadata:summary',
+      kind: 'yaml-metadata',
+      text: summarizeYamlMetadata(domainMetadata),
+    }],
+  });
+}
+
+function inferOnebaseYamlMetadata(filePath, text) {
+  const normalizedPath = String(filePath).replace(/\\/gu, '/').toLowerCase();
+  const artifactKind = normalizedPath.includes('/catalogs/')
+    ? 'catalog'
+    : normalizedPath.includes('/documents/')
+      ? 'document'
+      : normalizedPath.includes('/reports/')
+        ? 'report'
+        : normalizedPath.includes('/widgets/')
+          ? 'widget'
+          : normalizedPath.includes('/registers/')
+            ? 'register'
+            : 'yaml';
+
+  const nameMatch = text.match(/^name:\s*(.+)$/mu);
+  const postingMatch = text.match(/^posting:\s*(.+)$/mu);
+  const fields = [...text.matchAll(/-\s*\{\s*name:\s*([^,]+),\s*type:\s*([^}]+)\}/gu)]
+    .map((match) => ({ name: match[1].trim(), type: match[2].trim() }));
+
+  return {
+    artifactKind,
+    basename: basenameFromPath(filePath),
+    name: nameMatch?.[1]?.trim() ?? null,
+    posting: postingMatch?.[1]?.trim() ?? null,
+    fields,
+    hierarchical: /^hierarchical:\s*true/mu.test(text),
+  };
+}
+
+function summarizeYamlMetadata(metadata) {
+  const parts = [
+    metadata.artifactKind ? `kind=${metadata.artifactKind}` : '',
+    metadata.name ? `name=${metadata.name}` : '',
+    metadata.posting ? `posting=${metadata.posting}` : '',
+    metadata.fields?.length ? `fields=${metadata.fields.length}` : '',
+  ].filter(Boolean);
+
+  return parts.join(' ');
+}