@ai-content-space/loopx 0.2.8 → 0.2.10

package/src/loopx-context-artifacts.mjs

@@ -0,0 +1,114 @@
+import { existsSync } from 'node:fs';
+import { readFile, readdir } from 'node:fs/promises';
+import { basename, join, relative, resolve } from 'node:path';
+
+const MAX_SPEC_CONTEXT_FILES = 12;
+
+function displayPath(cwd, path) {
+  const rel = relative(cwd, path);
+  return rel && !rel.startsWith('..') ? rel : path;
+}
+
+function normalizeChangedFiles(files = []) {
+  return Array.isArray(files)
+    ? files.map((file) => String(file || '').trim()).filter(Boolean)
+    : [];
+}
+
+async function listMarkdownFiles(root) {
+  if (!existsSync(root)) {
+    return [];
+  }
+  const found = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(path);
+        continue;
+      }
+      if (entry.isFile() && /\.md$/i.test(entry.name)) {
+        found.push(path);
+      }
+    }
+  }
+  await walk(root);
+  return found;
+}
+
+function pathParts(value) {
+  return String(value || '')
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((part) => part.length >= 3);
+}
+
+function frontmatterAppliesTo(text) {
+  if (!String(text || '').startsWith('---\n')) {
+    return [];
+  }
+  const end = text.indexOf('\n---\n', 4);
+  if (end === -1) {
+    return [];
+  }
+  const lines = text.slice(4, end).split('\n');
+  const values = [];
+  let inAppliesTo = false;
+  for (const line of lines) {
+    if (/^applies_to:\s*$/.test(line)) {
+      inAppliesTo = true;
+      continue;
+    }
+    if (inAppliesTo && /^\s+-\s+/.test(line)) {
+      values.push(line.replace(/^\s+-\s+/, '').trim().replace(/^['"]|['"]$/g, ''));
+      continue;
+    }
+    if (inAppliesTo && /^\S/.test(line)) {
+      inAppliesTo = false;
+    }
+  }
+  return values.filter(Boolean);
+}
+
+function appliesToChangedFile(pattern, changedFile) {
+  const normalizedPattern = String(pattern || '').replace(/\*\*?\/?/g, '').replace(/\/+$/, '');
+  const normalizedFile = String(changedFile || '');
+  return normalizedPattern && normalizedFile.includes(normalizedPattern);
+}
+
+async function specRecord(cwd, path, changedFiles) {
+  const text = await readFile(path, 'utf8');
+  const appliesTo = frontmatterAppliesTo(text);
+  const stemParts = pathParts(basename(path, '.md'));
+  const changedParts = new Set(changedFiles.flatMap(pathParts));
+  const filenameMatch = stemParts.some((part) => changedParts.has(part));
+  const appliesToMatch = appliesTo.some((pattern) => changedFiles.some((file) => appliesToChangedFile(pattern, file)));
+  const isIndex = /(^|\/)index\.md$/i.test(path);
+  const isInbox = /(^|\/)inbox\.md$/i.test(path);
+  return {
+    path: displayPath(cwd, path),
+    appliesTo,
+    relevant: isIndex || isInbox || filenameMatch || appliesToMatch || changedFiles.length === 0,
+  };
+}
+
+export async function discoverLoopxContextArtifacts(cwd, options = {}) {
+  const root = resolve(cwd);
+  const changedFiles = normalizeChangedFiles(options.changedFiles);
+  const specsRootPath = join(root, 'docs', 'loopx', 'specs');
+  const specPaths = await listMarkdownFiles(specsRootPath);
+  const records = await Promise.all(specPaths.map((path) => specRecord(root, path, changedFiles)));
+  const relevantSpecs = records
+    .filter((record) => record.relevant)
+    .sort((left, right) => left.path.localeCompare(right.path))
+    .slice(0, MAX_SPEC_CONTEXT_FILES);
+  const memorySummaryPath = join(root, '.loopx', 'memory', 'MEMORY.md');
+  const memoryIndexPath = join(root, '.loopx', 'memory', 'index.jsonl');
+  return {
+    specsRoot: existsSync(specsRootPath) ? displayPath(root, specsRootPath) : null,
+    specFiles: relevantSpecs,
+    memorySummary: existsSync(memorySummaryPath) ? { path: displayPath(root, memorySummaryPath) } : null,
+    memoryIndex: existsSync(memoryIndexPath) ? { path: displayPath(root, memoryIndexPath) } : null,
+  };
+}

package/src/project-discovery.mjs

@@ -67,6 +67,7 @@ async function discoverSpecSources(cwd) {
     candidate(join(cwd, 'specs'), 'specs'),
     candidate(join(cwd, 'docs', 'changes'), 'docs/changes'),
     candidate(join(cwd, 'docs', 'specs'), 'docs/specs'),
+    candidate(join(cwd, 'docs', 'loopx', 'specs'), 'docs/loopx/specs'),
     candidate(join(cwd, 'docs', 'adr'), 'docs/adr'),
     candidate(join(cwd, 'docs', 'rfcs'), 'docs/rfcs'),
   ]);

package/src/workflow.mjs

@@ -20,6 +20,7 @@ import { inspectProjectConventions } from './project-discovery.mjs';
 import { createDefaultReviewAdapter } from './review-runtime.mjs';
 import { appendWorkspaceJournal } from './workspace-memory.mjs';
 import { inspectWorkspaceContext, setupWorkspaceContext } from './workspace-context.mjs';
+import { discoverLoopxContextArtifacts } from './loopx-context-artifacts.mjs';
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 const WORKSPACE_SCHEMA_VERSION = 1;
@@ -325,9 +326,6 @@ function compactPlanningText(text, { html = false } = {}) {
 async function readPlanSourceText(cwd, state, sourceSpecPath) {
   const sourceText = await readFile(sourceSpecPath, 'utf8');
   const sourceDocumentPaths = sourceDocumentPathsFromSpecAndState(sourceSpecPath, sourceText, state);
-  if (sourceDocumentPaths.length === 0) {
-    return { sourceText, sourceDocumentPaths: [] };
-  }
 
   const parts = [sourceText.trimEnd()];
   const loaded = [];
@@ -350,6 +348,11 @@ async function readPlanSourceText(cwd, state, sourceSpecPath) {
       break;
     }
   }
+  const repoContext = await readLoopxRepoContextText(cwd, sourceSpecPath);
+  if (repoContext.text) {
+    parts.push(repoContext.text);
+    loaded.push(...repoContext.paths);
+  }
 
   return {
     sourceText: parts.join('\n\n').slice(0, MAX_PLAN_SOURCE_BUNDLE_CHARS),
@@ -357,6 +360,47 @@ async function readPlanSourceText(cwd, state, sourceSpecPath) {
   };
 }
 
+async function readLoopxRepoContextText(cwd, sourceSpecPath) {
+  const artifacts = await discoverLoopxContextArtifacts(cwd, {
+    changedFiles: [relative(cwd, sourceSpecPath)],
+  });
+  const paths = [
+    ...artifacts.specFiles.map((item) => item.path),
+    artifacts.memorySummary?.path,
+  ].filter(Boolean);
+  if (paths.length === 0) {
+    return { text: '', paths: [] };
+  }
+  const sections = [];
+  const loaded = [];
+  for (const display of paths) {
+    const absolute = resolve(cwd, display);
+    if (!existsSync(absolute)) {
+      continue;
+    }
+    const raw = await readFile(absolute, 'utf8');
+    loaded.push(absolute);
+    sections.push([
+      `# loopx context: ${display}`,
+      '',
+      compactPlanningText(raw),
+    ].join('\n'));
+  }
+  if (sections.length === 0) {
+    return { text: '', paths: [] };
+  }
+  return {
+    text: [
+      '# loopx Repo Specs And Memory Context',
+      '',
+      'Current task instructions and named source documents have priority. Repo specs are binding long-lived rules. Memory is advisory.',
+      '',
+      ...sections,
+    ].join('\n\n'),
+    paths: loaded,
+  };
+}
+
 function frontmatterBlock(values) {
   const lines = ['---'];
   for (const [key, value] of Object.entries(values)) {