@ai-content-space/loopx 0.1.4 → 0.1.6

package/src/project-discovery.mjs

@@ -0,0 +1,163 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+
+async function readJsonIfExists(path) {
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function pathKind(path) {
+  if (!existsSync(path)) {
+    return null;
+  }
+  const info = await stat(path);
+  return info.isDirectory() ? 'directory' : 'file';
+}
+
+async function candidate(path, label) {
+  const kind = await pathKind(path);
+  if (!kind) {
+    return null;
+  }
+  return { path: label, kind };
+}
+
+async function directoryChildren(root, label) {
+  if (!existsSync(root)) {
+    return [];
+  }
+  const info = await stat(root);
+  if (!info.isDirectory()) {
+    return [];
+  }
+  const entries = await readdir(root);
+  return entries
+    .filter((entry) => /\.(md|mdc|txt)$/i.test(entry))
+    .sort()
+    .map((entry) => ({ path: `${label}/${entry}`, kind: 'file' }));
+}
+
+async function discoverAiRules(cwd) {
+  const direct = await Promise.all([
+    candidate(join(cwd, 'AGENTS.md'), 'AGENTS.md'),
+    candidate(join(cwd, 'CLAUDE.md'), 'CLAUDE.md'),
+    candidate(join(cwd, '.cursor', 'rules'), '.cursor/rules'),
+    candidate(join(cwd, '.github', 'copilot-instructions.md'), '.github/copilot-instructions.md'),
+  ]);
+  return [
+    ...direct.filter(Boolean),
+    ...await directoryChildren(join(cwd, '.cursor', 'rules'), '.cursor/rules'),
+  ].filter((item, index, items) => items.findIndex((other) => other.path === item.path) === index);
+}
+
+async function discoverSpecSources(cwd) {
+  const direct = await Promise.all([
+    candidate(join(cwd, 'openspec.yaml'), 'openspec.yaml'),
+    candidate(join(cwd, 'openspec.yml'), 'openspec.yml'),
+    candidate(join(cwd, 'openspec.json'), 'openspec.json'),
+    candidate(join(cwd, 'open-spec.yaml'), 'open-spec.yaml'),
+    candidate(join(cwd, '.specify'), '.specify'),
+    candidate(join(cwd, 'specs'), 'specs'),
+    candidate(join(cwd, 'docs', 'changes'), 'docs/changes'),
+    candidate(join(cwd, 'docs', 'specs'), 'docs/specs'),
+    candidate(join(cwd, 'docs', 'adr'), 'docs/adr'),
+    candidate(join(cwd, 'docs', 'rfcs'), 'docs/rfcs'),
+  ]);
+  return direct.filter(Boolean);
+}
+
+function packageRunner(cwd, packageJson) {
+  const packageManager = String(packageJson?.packageManager || '');
+  if (packageManager.startsWith('pnpm@') || existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  if (packageManager.startsWith('yarn@') || existsSync(join(cwd, 'yarn.lock'))) {
+    return 'yarn';
+  }
+  if (packageManager.startsWith('bun@') || existsSync(join(cwd, 'bun.lock')) || existsSync(join(cwd, 'bun.lockb'))) {
+    return 'bun';
+  }
+  return 'npm';
+}
+
+function runScriptCommand(runner, scriptName) {
+  if (runner === 'npm') {
+    return scriptName === 'test' ? 'npm test' : `npm run ${scriptName}`;
+  }
+  return `${runner} ${scriptName}`;
+}
+
+function firstScript(scripts, names) {
+  return names.find((name) => Object.prototype.hasOwnProperty.call(scripts, name));
+}
+
+async function discoverPackageCommands(cwd) {
+  const packageJson = await readJsonIfExists(join(cwd, 'package.json'));
+  if (!packageJson) {
+    return {};
+  }
+  const runner = packageRunner(cwd, packageJson);
+  const scripts = packageJson.scripts || {};
+  const install = runner === 'npm' && existsSync(join(cwd, 'package-lock.json'))
+    ? 'npm ci'
+    : `${runner} install`;
+  return {
+    install,
+    test: scripts.test ? runScriptCommand(runner, 'test') : null,
+    lint: scripts.lint ? runScriptCommand(runner, 'lint') : null,
+    typecheck: scripts.typecheck ? runScriptCommand(runner, 'typecheck') : null,
+    build: scripts.build ? runScriptCommand(runner, 'build') : null,
+    e2e: (() => {
+      const script = firstScript(scripts, ['test:e2e', 'e2e', 'test:browser', 'playwright']);
+      return script ? runScriptCommand(runner, script) : null;
+    })(),
+  };
+}
+
+function compactCommands(commands) {
+  return Object.fromEntries(
+    ['install', 'test', 'lint', 'typecheck', 'build', 'e2e']
+      .map((key) => [key, commands[key] || null]),
+  );
+}
+
+export async function discoverVerificationCommands(cwd) {
+  const packageCommands = await discoverPackageCommands(cwd);
+  if (Object.keys(packageCommands).length > 0) {
+    return compactCommands(packageCommands);
+  }
+  if (existsSync(join(cwd, 'go.mod'))) {
+    return compactCommands({
+      test: 'go test ./...',
+      build: 'go build ./...',
+    });
+  }
+  if (existsSync(join(cwd, 'pyproject.toml'))) {
+    return compactCommands({
+      install: 'pip install -e .',
+      test: 'pytest',
+    });
+  }
+  return compactCommands({});
+}
+
+export async function inspectProjectConventions(cwd) {
+  const [existingAiRules, existingSpecSources, verificationCommands] = await Promise.all([
+    discoverAiRules(cwd),
+    discoverSpecSources(cwd),
+    discoverVerificationCommands(cwd),
+  ]);
+  return {
+    existing_ai_rules: existingAiRules,
+    existing_spec_sources: existingSpecSources,
+    verification_commands: verificationCommands,
+    source_of_truth_policy: 'preserve-existing-project-rules-and-use-loopx-artifacts-only-after-init',
+  };
+}

package/src/workflow.mjs

@@ -16,6 +16,7 @@ import {
 import { doctorRuntime, ensureLoopxRoot, resolveLoopxRoot } from './runtime-maintenance.mjs';
 import { DEFAULT_BUILD_MAX_ITERATIONS, createDefaultBuildAdapter } from './build-runtime.mjs';
 import { DEFAULT_MAX_ITERATIONS, createDefaultPlanAdapter } from './plan-runtime.mjs';
+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';
@@ -356,7 +357,7 @@ function buildWorkspaceReadme() {
     '- `workflows/<slug>/spec.md`',
     '- `workflows/<slug>/plan.md`, `architecture.md`, `development-plan.md`, and `test-plan.md`',
     '- `workflows/<slug>/execution-record.md` and `review-report.md`',
-    '- `views/index.html` and `workflows/<slug>/view/index.html` after `loopx render`',
+    '- `views/index.html` and `workflows/<slug>/view/index.html` after `loopx plan` or `loopx render`',
     '',
     'Documents users may read and edit as workflow fact sources:',
     '',
@@ -2507,8 +2508,31 @@ async function refreshExecutionStatus(root, state) {
   };
 }
 
+async function renderPlanReadingViews(cwd, root, state, slug) {
+  try {
+    const { renderHtmlViews } = await import('./html-views.mjs');
+    const rendered = await renderHtmlViews(cwd, { slug });
+    return {
+      ...state,
+      html_view_status: 'written',
+      html_view_path: rendered.workflowViewPath,
+      workspace_view_path: rendered.workspaceViewPath,
+      html_view_error: null,
+    };
+  } catch (error) {
+    return {
+      ...state,
+      html_view_status: 'failed',
+      html_view_path: join(root, 'view', 'index.html'),
+      workspace_view_path: join(resolveWorkspaceRoot(cwd), 'views', 'index.html'),
+      html_view_error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 export async function initWorkspace(cwd, { slug } = {}) {
   const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const projectConventions = await inspectProjectConventions(cwd);
   await ensureLoopxRoot(cwd);
   await ensureDir(join(workspaceRoot, 'context'));
   await ensureDir(join(workspaceRoot, 'intake'));
@@ -2527,6 +2551,12 @@ export async function initWorkspace(cwd, { slug } = {}) {
     product_contract: 'skill-first-v1',
     default_flow: ['clarify', 'plan', 'build', 'review', 'done', 'archive'],
     preferred_surface: ['clarify', 'plan', 'build', 'review', 'archive', 'autopilot'],
+    source_of_truth_policy: projectConventions.source_of_truth_policy,
+    project_conventions: {
+      existing_ai_rules: projectConventions.existing_ai_rules,
+      existing_spec_sources: projectConventions.existing_spec_sources,
+    },
+    verification_commands: projectConventions.verification_commands,
   };
 
   if (!existsSync(workspaceConfigPath(workspaceRoot))) {
@@ -2777,8 +2807,64 @@ export async function approveStage(cwd, slug, { from, to }) {
   return { root, state: next };
 }
 
+function isDoneRoute(value) {
+  return value === TRANSITIONS.REVIEW_TO_DONE || value === STAGES.DONE;
+}
+
+function canArchiveConsumePendingDoneApproval(state) {
+  if (state.current_stage !== STAGES.REVIEW) {
+    return false;
+  }
+  const reviewVerdict = String(state.review_verdict || '').trim().toLowerCase();
+  const reviewApproved = reviewVerdict === 'approve' || reviewVerdict === 'go';
+  const routesToDone = [
+    state.pending_user_decision,
+    state.requested_transition,
+    state.review_route,
+    state.requested_transition_after_review,
+  ].some(isDoneRoute);
+  const completionRequested = [
+    APPROVAL_STATES.REQUESTED,
+    APPROVAL_STATES.APPROVED,
+  ].includes(state.approval?.complete) || state.execution_approved === true || state.execution_approved_for_review === true;
+  return reviewApproved && routesToDone && completionRequested;
+}
+
+async function consumePendingDoneApprovalForArchive(cwd, root, state, slug) {
+  if (!canArchiveConsumePendingDoneApproval(state)) {
+    return { root, state, consumed: false };
+  }
+  const normalized = withRecommendedAction({
+    ...state,
+    review_verdict: 'approve',
+    pending_user_decision: TRANSITIONS.REVIEW_TO_DONE,
+    requested_transition: TRANSITIONS.NONE,
+    approval: {
+      ...state.approval,
+      review: APPROVAL_STATES.APPROVED,
+      complete: state.approval?.complete || APPROVAL_STATES.REQUESTED,
+    },
+  });
+  await writeState(root, normalized);
+  const done = await approveStage(cwd, slug, { from: STAGES.REVIEW, to: STAGES.DONE });
+  return {
+    root: done.root,
+    state: {
+      ...done.state,
+      archive_consumed_pending_done_approval: true,
+    },
+    consumed: true,
+  };
+}
+
 export async function archiveStage(cwd, slug) {
-  const { root, state, slug: normalized } = await loadWorkflowState(cwd, slug, { allowLegacy: false });
+  const loaded = await loadWorkflowState(cwd, slug, { allowLegacy: false });
+  const normalized = loaded.slug;
+  let root = loaded.root;
+  let state = loaded.state;
+  const doneApproval = await consumePendingDoneApprovalForArchive(cwd, root, state, normalized);
+  root = doneApproval.root;
+  state = doneApproval.state;
   if (state.current_stage !== STAGES.DONE || !state.completion_confirmed) {
     throw new Error('archive_requires_done_workflow');
   }
@@ -2996,7 +3082,9 @@ export async function planStage(cwd, slug, options = {}) {
     build_context_manifest_path: buildManifest?.path || buildContextManifestPath(root),
   });
   await writeState(root, next);
-  return { root, state: next, architectReview, criticReview };
+  const renderedNext = await renderPlanReadingViews(cwd, root, next, normalized);
+  await writeState(root, renderedNext);
+  return { root, state: renderedNext, architectReview, criticReview };
 }
 
 export async function buildStage(cwd, slug, options = {}) {