@work-graph/cli 0.2.0

package/vendor/src/lowcodeScaffoldCli.mjs

@@ -0,0 +1,386 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+
+export const LOWCODE_SCAFFOLD_MANIFEST_SCHEMA = 'workgraph.lowcode.scaffold.manifest.v1';
+export const LOWCODE_SCAFFOLD_SUMMARY_SCHEMA = 'workgraph.lowcode.scaffold.summary.v1';
+
+export const DEFAULT_ARCH_RULES_PATH = 'tests/fixtures/low-code-charter/arch-rules.bvc';
+export const DEFAULT_SCAFFOLD_OUTPUT_DIR = 'generated/arch-scaffold';
+
+const ARCH_RULE_BLOCK_PATTERN = /^#([^\n<]+)<\[\n([\s\S]*?)\n\]>/gmu;
+const METADATA_TAG_PATTERN = /\/\*([^:]+):\s*([^*]+)\*\//gu;
+
+export function parseArchRulesStepText(text) {
+  if (typeof text !== 'string') {
+    throw new TypeError('text must be a string');
+  }
+
+  const rules = [];
+  const errors = [];
+
+  for (const match of text.matchAll(ARCH_RULE_BLOCK_PATTERN)) {
+    const [, rawName, body] = match;
+    const name = rawName.trim();
+
+    if (name === 'ioHascSync' || name.startsWith('ioHasc')) {
+      continue;
+    }
+
+    const parsed = parseArchRuleBody(name, body);
+    if (parsed.errors.length > 0) {
+      errors.push(...parsed.errors.map((detail) => `${name}: ${detail}`));
+      continue;
+    }
+
+    if (parsed.rule) {
+      rules.push(parsed.rule);
+    }
+  }
+
+  if (rules.length === 0) {
+    errors.push('no arch rules found in charter text');
+  }
+
+  return {
+    ok: errors.length === 0,
+    rules,
+    errors,
+  };
+}
+
+function parseArchRuleBody(name, body) {
+  const errors = [];
+  const rule = {
+    id: name,
+    name,
+    basis: '',
+    vector: '',
+    goal: '',
+    metadata: {},
+    metadataRaw: '',
+  };
+
+  for (const rawLine of body.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (line === '') {
+      continue;
+    }
+
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex === -1) {
+      errors.push(`unsupported line: ${line}`);
+      continue;
+    }
+
+    const key = line.slice(0, separatorIndex).trim();
+    const value = line.slice(separatorIndex + 1).trim();
+
+    if (key === 'Базис') {
+      rule.basis = value;
+      continue;
+    }
+
+    if (key === 'Вектор') {
+      rule.vector = value;
+      continue;
+    }
+
+    if (key === 'Цель') {
+      rule.goal = value;
+      continue;
+    }
+
+    if (key === 'Метаданные') {
+      rule.metadataRaw = value;
+      rule.metadata = parseMetadataTags(value);
+      continue;
+    }
+
+    errors.push(`unknown field ${key}`);
+  }
+
+  if (!rule.basis || !rule.vector || !rule.goal) {
+    errors.push('missing basis/vector/goal');
+    return { rule: null, errors };
+  }
+
+  return { rule, errors };
+}
+
+export function parseMetadataTags(value) {
+  const metadata = {};
+
+  for (const match of String(value).matchAll(METADATA_TAG_PATTERN)) {
+    metadata[match[1].trim()] = match[2].trim();
+  }
+
+  return metadata;
+}
+
+export function buildArchRulesScaffoldSummary(options = {}) {
+  const charterPath = normalizeRepoPath(options.charterPath ?? DEFAULT_ARCH_RULES_PATH);
+  const outputDir = normalizeRepoPath(options.outputDir ?? DEFAULT_SCAFFOLD_OUTPUT_DIR);
+  const parsed = options.parsed ?? parseArchRulesStepText(options.charterText ?? '');
+
+  return {
+    schema: LOWCODE_SCAFFOLD_SUMMARY_SCHEMA,
+    ok: parsed.ok,
+    charterPath,
+    outputDir,
+    ruleCount: parsed.rules.length,
+    rules: parsed.rules.map((rule) => ({
+      id: rule.id,
+      domain: rule.metadata.domain ?? null,
+      severity: rule.metadata.severity ?? null,
+      pattern: rule.metadata.pattern ?? null,
+    })),
+    errors: parsed.errors,
+    generatedAt: options.generatedAt ?? new Date().toISOString(),
+  };
+}
+
+export function buildArchRuleStubModule(rule) {
+  const domain = rule.metadata.domain ?? 'unknown';
+  const severity = rule.metadata.severity ?? 'unknown';
+  const pattern = rule.metadata.pattern ?? null;
+
+  return `// Generated arch guard stub for ${rule.id}
+export const ruleId = ${JSON.stringify(rule.id)};
+export const domain = ${JSON.stringify(domain)};
+export const severity = ${JSON.stringify(severity)};
+export const pattern = ${pattern ? JSON.stringify(pattern) : 'null'};
+export const summary = ${JSON.stringify({
+    basis: rule.basis,
+    vector: rule.vector,
+    goal: rule.goal,
+  }, null, 2)};
+
+export function guardPlaceholder() {
+  return {
+    status: 'stub',
+    ruleId,
+    message: 'Wire arch guard scanner in sidecar or CI optional gate.',
+  };
+}
+`;
+}
+
+export function buildScaffoldManifest(summary, filesWritten) {
+  return {
+    schema: LOWCODE_SCAFFOLD_MANIFEST_SCHEMA,
+    charterPath: summary.charterPath,
+    outputDir: summary.outputDir,
+    generatedAt: summary.generatedAt,
+    ruleCount: summary.ruleCount,
+    rules: summary.rules,
+    filesWritten,
+  };
+}
+
+export async function writeArchRulesScaffold(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const charterPath = resolve(cwd, options.charterPath ?? DEFAULT_ARCH_RULES_PATH);
+  const outputDir = resolve(cwd, options.outputDir ?? DEFAULT_SCAFFOLD_OUTPUT_DIR);
+  const dryRun = options.dryRun === true;
+  const charterText = options.charterText ?? await readFile(charterPath, 'utf8');
+  const parsed = parseArchRulesStepText(charterText);
+
+  const summary = buildArchRulesScaffoldSummary({
+    charterPath: relative(cwd, charterPath).replace(/\\/g, '/'),
+    outputDir: relative(cwd, outputDir).replace(/\\/g, '/'),
+    parsed,
+    generatedAt: options.generatedAt,
+  });
+
+  if (!parsed.ok) {
+    return {
+      ok: false,
+      summary,
+      manifest: null,
+      filesWritten: [],
+      errors: parsed.errors,
+    };
+  }
+
+  const filesWritten = [];
+  const plannedFiles = [];
+
+  for (const rule of parsed.rules) {
+    const stubName = `${rule.id}.guard.stub.mjs`;
+    plannedFiles.push({
+      relativePath: `rules/${stubName}`,
+      contents: buildArchRuleStubModule(rule),
+    });
+  }
+
+  plannedFiles.push({
+    relativePath: 'README.md',
+    contents: buildScaffoldReadme(summary, parsed.rules),
+  });
+
+  if (dryRun) {
+    return {
+      ok: true,
+      summary,
+      manifest: buildScaffoldManifest(summary, plannedFiles.map((file) => file.relativePath)),
+      filesWritten: plannedFiles.map((file) => file.relativePath),
+      errors: [],
+      dryRun: true,
+    };
+  }
+
+  await mkdir(outputDir, { recursive: true });
+  await mkdir(resolve(outputDir, 'rules'), { recursive: true });
+
+  for (const file of plannedFiles) {
+    const absolutePath = resolve(outputDir, file.relativePath);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, file.contents, 'utf8');
+    filesWritten.push(relative(cwd, absolutePath).replace(/\\/g, '/'));
+  }
+
+  const manifest = buildScaffoldManifest(summary, filesWritten);
+  const manifestPath = resolve(outputDir, 'manifest.json');
+  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+  filesWritten.push(relative(cwd, manifestPath).replace(/\\/g, '/'));
+
+  return {
+    ok: true,
+    summary,
+    manifest,
+    filesWritten,
+    errors: [],
+    dryRun: false,
+  };
+}
+
+function buildScaffoldReadme(summary, rules) {
+  const lines = [
+    '# Arch rules scaffold (Work Graph low-code MVP)',
+    '',
+    `Charter: \`${summary.charterPath}\``,
+    `Generated: ${summary.generatedAt}`,
+    `Rules: ${summary.ruleCount}`,
+    '',
+    'This directory is a deterministic stub scaffold. Full TurIr/Handlebars generation remains deferred to ../project until sidecar boundary closes.',
+    '',
+    '## Rules',
+    '',
+    ...rules.map((rule) => `- \`${rule.id}\` (${rule.metadata.domain ?? 'unknown'} / ${rule.metadata.severity ?? 'unknown'})`),
+    '',
+  ];
+
+  return `${lines.join('\n')}\n`;
+}
+
+export async function validateArchRulesCharter(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const charterPath = resolve(cwd, options.charterPath ?? DEFAULT_ARCH_RULES_PATH);
+
+  try {
+    const charterText = await readFile(charterPath, 'utf8');
+    const parsed = parseArchRulesStepText(charterText);
+
+    return {
+      ok: parsed.ok,
+      charterPath: relative(cwd, charterPath).replace(/\\/g, '/'),
+      ruleCount: parsed.rules.length,
+      errors: parsed.errors,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      charterPath: relative(cwd, charterPath).replace(/\\/g, '/'),
+      ruleCount: 0,
+      errors: [error instanceof Error ? error.message : String(error)],
+    };
+  }
+}
+
+export async function runLowcodeVerify(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const charterPath = options.charterPath ?? DEFAULT_ARCH_RULES_PATH;
+  const charterValidation = await validateArchRulesCharter({ cwd, charterPath });
+
+  if (!charterValidation.ok) {
+    return {
+      ok: false,
+      schema: 'workgraph.lowcode.verify.v1',
+      charter: charterValidation,
+      scaffoldDryRun: null,
+      errors: charterValidation.errors,
+    };
+  }
+
+  const charterText = await readFile(resolve(cwd, charterPath), 'utf8');
+  const scaffoldDryRun = await writeArchRulesScaffold({
+    cwd,
+    charterPath,
+    charterText,
+    dryRun: true,
+    outputDir: options.outputDir ?? DEFAULT_SCAFFOLD_OUTPUT_DIR,
+    generatedAt: options.generatedAt,
+  });
+
+  const ok = scaffoldDryRun.ok;
+  const errors = ok ? [] : [...charterValidation.errors, ...scaffoldDryRun.errors];
+
+  return {
+    ok,
+    schema: 'workgraph.lowcode.verify.v1',
+    charter: charterValidation,
+    scaffoldDryRun: {
+      ok: scaffoldDryRun.ok,
+      ruleCount: scaffoldDryRun.summary.ruleCount,
+      filesPlanned: scaffoldDryRun.filesWritten,
+    },
+    errors,
+  };
+}
+
+export function parseLowcodeCliArgs(argv) {
+  const options = {
+    charterPath: DEFAULT_ARCH_RULES_PATH,
+    outputDir: DEFAULT_SCAFFOLD_OUTPUT_DIR,
+    dryRun: false,
+    json: false,
+    command: 'scaffold',
+  };
+
+  const args = [...argv];
+
+  if (args[0] === 'verify') {
+    options.command = 'verify';
+    args.shift();
+  }
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+
+    if (token === '--charter' && args[index + 1]) {
+      options.charterPath = args[++index];
+      continue;
+    }
+
+    if (token === '--output' && args[index + 1]) {
+      options.outputDir = args[++index];
+      continue;
+    }
+
+    if (token === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (token === '--json') {
+      options.json = true;
+      continue;
+    }
+  }
+
+  return options;
+}
+
+function normalizeRepoPath(value) {
+  return String(value).replace(/\\/g, '/');
+}

package/vendor/src/markdownDocumentRender.mjs

@@ -0,0 +1,208 @@
+import { highlightCodeBlock, normalizeCodeLanguage } from './codeSyntaxHighlight.mjs';
+
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+export function renderInlineMarkdown(text) {
+  const tickParts = String(text ?? '').split('`');
+
+  return tickParts.map((chunk, index) => {
+    if (index % 2 === 1) {
+      return `<code class="inline-term">${escapeHtml(chunk)}</code>`;
+    }
+
+    const boldParts = chunk.split('**');
+    return boldParts.map((part, boldIndex) => {
+      if (boldIndex % 2 === 1) {
+        return `<strong>${escapeHtml(part)}</strong>`;
+      }
+
+      return escapeHtml(part);
+    }).join('');
+  }).join('');
+}
+
+function splitTableRow(line) {
+  return line
+    .trim()
+    .replace(/^\|/u, '')
+    .replace(/\|$/u, '')
+    .split('|')
+    .map((cell) => cell.trim());
+}
+
+function isTableSeparator(line) {
+  return /^\|?(?:\s*:?-{3,}:?\s*\|)+\s*:?-{3,}:?\s*\|?$/u.test(String(line ?? '').trim());
+}
+
+function renderMarkdownTable(headerCells, bodyRows) {
+  const head = headerCells.map((cell) => `<th>${renderInlineMarkdown(cell)}</th>`).join('');
+  const body = bodyRows.map((row) =>
+    `<tr>${row.map((cell) => `<td>${renderInlineMarkdown(cell)}</td>`).join('')}</tr>`,
+  ).join('');
+
+  return `<div class="markdown-table-wrap"><table class="markdown-table"><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table></div>`;
+}
+
+export function stripAnalyticsBodyPreamble(text) {
+  const lines = String(text ?? '').split(/\r?\n/u);
+  let index = 0;
+
+  if (/^#\s+/u.test(lines[index]?.trim() ?? '')) {
+    index += 1;
+  }
+
+  while (index < lines.length && lines[index].trim() === '') {
+    index += 1;
+  }
+
+  while (index < lines.length) {
+    const trimmed = lines[index].trim();
+
+    if (trimmed === '') {
+      index += 1;
+      continue;
+    }
+
+    if (/^\*\*Запрос:\*\*/u.test(trimmed)) {
+      index += 1;
+      continue;
+    }
+
+    if (/^\*\*Тема:\*\*/u.test(trimmed)) {
+      index += 1;
+      continue;
+    }
+
+    if (/^\*\*Связанные файлы:\*\*/u.test(trimmed)) {
+      index += 1;
+      continue;
+    }
+
+    if (/^---+$|^___+$|^\*\*\*+$/u.test(trimmed)) {
+      index += 1;
+      continue;
+    }
+
+    break;
+  }
+
+  while (index < lines.length && lines[index].trim() === '') {
+    index += 1;
+  }
+
+  return lines.slice(index).join('\n').trim();
+}
+
+function escapeMermaidSource(text) {
+  return String(text ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;');
+}
+
+export function renderMarkdownDocument(text) {
+  const lines = String(text ?? '').split(/\r?\n/u);
+  const parts = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const rawLine = lines[index];
+    const trimmed = rawLine.trim();
+
+    if (trimmed === '') {
+      index += 1;
+      continue;
+    }
+
+    if (trimmed.startsWith('```')) {
+      const language = trimmed.slice(3).trim();
+      index += 1;
+      const codeLines = [];
+
+      while (index < lines.length && !lines[index].trim().startsWith('```')) {
+        codeLines.push(lines[index]);
+        index += 1;
+      }
+
+      if (index < lines.length) {
+        index += 1;
+      }
+
+      if (language === 'mermaid') {
+        const source = codeLines.join('\n');
+        parts.push(`<div class="markdown-mermaid-wrap" data-testid="markdown-mermaid"><div class="mermaid">${escapeMermaidSource(source)}</div></div>`);
+        continue;
+      }
+
+      const normalizedLanguage = normalizeCodeLanguage(language);
+      const highlighted = highlightCodeBlock(codeLines.join('\n'), normalizedLanguage);
+      const languageClass = normalizedLanguage === 'plaintext' ? '' : ` language-${normalizedLanguage}`;
+      parts.push(`<pre class="markdown-code-block"><code class="code-block${languageClass}">${highlighted}</code></pre>`);
+
+      continue;
+    }
+
+    if (/^---+$|^___+$|^\*\*\*+$/u.test(trimmed)) {
+      parts.push('<hr class="markdown-hr" />');
+      index += 1;
+      continue;
+    }
+
+    if (trimmed.includes('|') && index + 1 < lines.length && isTableSeparator(lines[index + 1])) {
+      const headerCells = splitTableRow(trimmed);
+      index += 2;
+      const bodyRows = [];
+
+      while (index < lines.length && lines[index].trim() !== '' && lines[index].trim().includes('|')) {
+        bodyRows.push(splitTableRow(lines[index]));
+        index += 1;
+      }
+
+      parts.push(renderMarkdownTable(headerCells, bodyRows));
+      continue;
+    }
+
+    const headingMatch = trimmed.match(/^(#{1,3})\s+(.+)$/u);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      const tag = level === 1 ? 'h1' : level === 2 ? 'h2' : 'h3';
+      parts.push(`<${tag} class="markdown-${tag}">${renderInlineMarkdown(headingMatch[2])}</${tag}>`);
+      index += 1;
+      continue;
+    }
+
+    if (/^[-*]\s+/u.test(trimmed)) {
+      const items = [];
+
+      while (index < lines.length && /^[-*]\s+/u.test(lines[index].trim())) {
+        items.push(lines[index].trim().replace(/^[-*]\s+/u, ''));
+        index += 1;
+      }
+
+      parts.push(`<ul class="markdown-list">${items.map((item) => `<li>${renderInlineMarkdown(item)}</li>`).join('')}</ul>`);
+      continue;
+    }
+
+    if (/^\d+\.\s+/u.test(trimmed)) {
+      const items = [];
+
+      while (index < lines.length && /^\d+\.\s+/u.test(lines[index].trim())) {
+        items.push(lines[index].trim().replace(/^\d+\.\s+/u, ''));
+        index += 1;
+      }
+
+      parts.push(`<ol class="markdown-list markdown-list--ordered">${items.map((item) => `<li>${renderInlineMarkdown(item)}</li>`).join('')}</ol>`);
+      continue;
+    }
+
+    parts.push(`<p class="markdown-p">${renderInlineMarkdown(trimmed)}</p>`);
+    index += 1;
+  }
+
+  return `<div class="markdown-doc">${parts.join('')}</div>`;
+}

package/vendor/src/memoryPanelProjection.mjs

@@ -0,0 +1,116 @@
+import { readWorkItemsFromRepo } from './intentTreeWorkItems.mjs';
+import {
+  buildMemoryRecordCandidatesFromItems,
+  mergeMemoryJournalWithCandidates,
+  readMemoryRecordJournal,
+} from './memoryRecordWriter.mjs';
+
+export const MEMORY_PANEL_PROJECTION_SCHEMA = 'memory-panel.projection.v1';
+export const MEMORY_RECORDS_API_SCHEMA = 'memory-records.api.v1';
+export const DEFAULT_MEMORY_RECORDS_LIMIT = 50;
+
+function summarizeRecords(records) {
+  const byType = {};
+  const byStatus = {};
+
+  for (const record of records) {
+    byType[record.type] = (byType[record.type] ?? 0) + 1;
+    byStatus[record.status] = (byStatus[record.status] ?? 0) + 1;
+  }
+
+  return {
+    total: records.length,
+    byType,
+    byStatus,
+    reviewRequired: records.filter((record) => record.reviewRequired).length,
+  };
+}
+
+export async function loadMergedMemoryRecords(options = {}) {
+  const items = options.items ?? await readWorkItemsFromRepo(options);
+  const candidates = buildMemoryRecordCandidatesFromItems(items, options).records;
+  let journalRecords = options.journalRecords;
+
+  if (journalRecords === undefined && options.includeJournal !== false) {
+    const journal = await readMemoryRecordJournal(options);
+    journalRecords = journal.records;
+  }
+
+  return mergeMemoryJournalWithCandidates(candidates, journalRecords ?? []);
+}
+
+export function filterMemoryRecords(records, options = {}) {
+  if (!Array.isArray(records)) {
+    throw new TypeError('records must be an array');
+  }
+
+  let filtered = records;
+  const workId = String(options.workId ?? '').trim();
+  if (workId !== '') {
+    filtered = filtered.filter((record) => record.sourceWorkItem === workId);
+  }
+
+  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,
+    workId: workId || null,
+  };
+}
+
+export function buildMemoryPanelProjectionFromRecords(records, options = {}) {
+  const summary = summarizeRecords(records);
+
+  return {
+    schema: MEMORY_PANEL_PROJECTION_SCHEMA,
+    readOnly: true,
+    reviewActionsEnabled: false,
+    source: options.source ?? 'merged-memory-records',
+    summary,
+    records,
+    filters: {
+      types: Object.keys(summary.byType).sort(),
+      statuses: Object.keys(summary.byStatus).sort(),
+    },
+  };
+}
+
+export function buildMemoryPanelProjectionFromItems(items, options = {}) {
+  if (!Array.isArray(items)) {
+    throw new TypeError('items must be an array');
+  }
+
+  const candidates = buildMemoryRecordCandidatesFromItems(items, options);
+  return buildMemoryPanelProjectionFromRecords(candidates.records, {
+    ...options,
+    source: 'done-work-items',
+  });
+}
+
+export async function buildMemoryRecordsApiResponse(options = {}) {
+  const records = await loadMergedMemoryRecords(options);
+  const filtered = filterMemoryRecords(records, {
+    workId: options.workId,
+    limit: options.limit ?? DEFAULT_MEMORY_RECORDS_LIMIT,
+  });
+
+  return {
+    schema: MEMORY_RECORDS_API_SCHEMA,
+    count: filtered.records.length,
+    truncated: filtered.truncated,
+    workId: filtered.workId,
+    limit: filtered.limit,
+    records: filtered.records,
+  };
+}
+
+export async function buildMemoryPanelProjection(options = {}) {
+  const records = await loadMergedMemoryRecords(options);
+  return buildMemoryPanelProjectionFromRecords(records, options);
+}