@vibecompass/vibecompass 0.3.4 → 0.5.0

package/src/setup.js

@@ -1,10 +1,13 @@
 import { execFile } from 'node:child_process';
 import { access, readFile, readdir, realpath } from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { promisify } from 'node:util';
 import { getSupportedAgentFilePaths } from './generators/agent-files/index.js';
 import { END_MARKER, START_MARKER } from './generators/agent-files/markers.js';
+import { parseSimpleYaml } from './simple-yaml.js';
+import { getWorkflowConflictScanPatterns } from './workflows/registry.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -22,6 +25,24 @@ export async function resolveInitCliOptions(options, environment = {}) {
   let guidedSummary = null;
 
   if (resolved.guided) {
+    if (!resolved.force) {
+      const existingProject = await resolveExistingGuidedProject(resolved, {
+        cwd,
+        io: environment.io,
+        runtime: environment.runtime,
+      });
+      if (existingProject) {
+        return {
+          existingProject,
+          initOptions: null,
+          placementPattern: null,
+          guidedSummary: null,
+          agentFileSyncPlan: null,
+          sessionPlan: null,
+        };
+      }
+    }
+
     const prompter = createPrompter(environment.io, environment.runtime);
     try {
       const guided = await completeGuidedInitOptions(resolved, {
@@ -60,6 +81,7 @@ export async function resolveInitCliOptions(options, environment = {}) {
       mode: resolved.mode,
       repos: resolved.repos,
       force: resolved.force,
+      replaceActiveLanes: resolved.replaceActiveLanes,
       sync: resolved.sync,
       bootstrap: resolved.bootstrap,
       generatedAt: resolved.generatedAt,
@@ -121,6 +143,212 @@ export async function resolveConnectHostedCliOptions(options, environment = {})
   };
 }
 
+async function resolveExistingGuidedProject(options, environment) {
+  const candidates = await findExistingGuidedProjectRoots(options, environment.cwd);
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  if (candidates.length === 1) {
+    if (candidates[0].discovery === 'ancestor' && canPrompt(environment)) {
+      const prompter = createPrompter(environment.io, environment.runtime);
+      try {
+        const useExistingRoot = await askConfirm(
+          prompter,
+          `Found existing VibeCompass project memory root at ${candidates[0].displayPath}. Show its info instead of initializing a new root here?`,
+          true,
+        );
+        if (!useExistingRoot) {
+          return null;
+        }
+      } finally {
+        await prompter.close();
+      }
+    }
+
+    return readExistingGuidedProject(candidates[0], environment.cwd);
+  }
+
+  return {
+    status: 'ambiguous',
+    candidates,
+  };
+}
+
+async function findExistingGuidedProjectRoots(options, cwd) {
+  const candidateRoots = options.rootDir
+    ? [{
+        rootDir: path.resolve(cwd, options.rootDir),
+        discovery: 'explicit',
+      }]
+    : await buildDefaultExistingRootCandidates(cwd);
+
+  const existing = [];
+  const seen = new Set();
+  for (const candidate of candidateRoots) {
+    const rootDir = candidate.rootDir;
+    if (seen.has(rootDir)) {
+      continue;
+    }
+    seen.add(rootDir);
+
+    if (await fileExists(path.join(rootDir, 'project.yaml'))) {
+      existing.push({
+        rootDir,
+        displayPath: toRelativeIfInsideCwd(rootDir, cwd),
+        discovery: candidate.discovery,
+      });
+    }
+  }
+
+  return existing;
+}
+
+async function buildDefaultExistingRootCandidates(cwd) {
+  const candidates = [
+    {
+      rootDir: path.resolve(cwd, '.compass'),
+      discovery: 'direct',
+    },
+    {
+      rootDir: path.resolve(cwd),
+      discovery: 'direct',
+    },
+  ];
+  const ancestorStopDir = await resolveAncestorSearchStopDir(cwd);
+  if (path.resolve(cwd) === ancestorStopDir) {
+    return candidates;
+  }
+
+  for (const directory of ancestorDirectories(path.dirname(cwd), ancestorStopDir)) {
+    candidates.push(
+      {
+        rootDir: path.join(directory, '.compass'),
+        discovery: 'ancestor',
+      },
+      {
+        rootDir: directory,
+        discovery: 'ancestor',
+      },
+    );
+  }
+
+  return candidates;
+}
+
+async function resolveAncestorSearchStopDir(cwd) {
+  const homeDir = path.resolve(os.homedir());
+  if (path.resolve(cwd) === homeDir) {
+    return homeDir;
+  }
+
+  const gitRoot = await readGitRoot(cwd);
+  if (!gitRoot) {
+    return isPathInside(cwd, homeDir) || path.resolve(cwd) === homeDir
+      ? homeDir
+      : path.parse(cwd).root;
+  }
+
+  const gitRootParent = path.dirname(path.resolve(gitRoot));
+  if (isPathInside(gitRootParent, homeDir) || gitRootParent === homeDir) {
+    return gitRootParent;
+  }
+
+  return isPathInside(cwd, homeDir) || path.resolve(cwd) === homeDir
+    ? homeDir
+    : path.parse(cwd).root;
+}
+
+function ancestorDirectories(startDir, stopDir) {
+  const directories = [];
+  let current = path.resolve(startDir);
+  const stop = path.resolve(stopDir);
+  while (true) {
+    directories.push(current);
+    if (current === stop || current === path.dirname(current)) {
+      break;
+    }
+    current = path.dirname(current);
+  }
+
+  return directories;
+}
+
+async function readExistingGuidedProject(candidate, cwd) {
+  const projectFilePath = path.join(candidate.rootDir, 'project.yaml');
+  const activeSummary = await readActiveLaneSummary(candidate.rootDir);
+  try {
+    const projectConfig = parseSimpleYaml(await readFile(projectFilePath, 'utf8'), {
+      sourceName: projectFilePath,
+    });
+
+    return {
+      status: 'ok',
+      rootDir: candidate.rootDir,
+      displayPath: candidate.displayPath ?? toRelativeIfInsideCwd(candidate.rootDir, cwd),
+      projectFilePath,
+      projectConfig,
+      activeSummary,
+    };
+  } catch (error) {
+    return {
+      status: 'unreadable',
+      rootDir: candidate.rootDir,
+      displayPath: candidate.displayPath ?? toRelativeIfInsideCwd(candidate.rootDir, cwd),
+      projectFilePath,
+      errorMessage: error instanceof Error ? error.message : 'Unable to read project.yaml.',
+      activeSummary,
+    };
+  }
+}
+
+async function readActiveLaneSummary(rootDir) {
+  const activeDir = path.join(rootDir, 'sessions', 'active');
+  let count = 0;
+  try {
+    const entries = await readdir(activeDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      const laneDir = path.join(activeDir, entry.name);
+      if (
+        (await fileExists(path.join(laneDir, 'session.yaml'))) ||
+        (await fileExists(path.join(laneDir, 'wip.md')))
+      ) {
+        count += 1;
+      }
+    }
+  } catch {
+    count = 0;
+  }
+
+  let current = null;
+  try {
+    const indexPath = path.join(activeDir, 'index.yaml');
+    const activeIndex = parseSimpleYaml(await readFile(indexPath, 'utf8'), {
+      sourceName: indexPath,
+    });
+    current = typeof activeIndex.current === 'string' && activeIndex.current !== 'null'
+      ? activeIndex.current
+      : null;
+  } catch {
+    current = null;
+  }
+
+  return { count, current };
+}
+
+function canPrompt(environment) {
+  if (typeof environment.runtime?.prompt === 'function') {
+    return true;
+  }
+
+  const input = environment.runtime?.stdin ?? environment.io?.stdin ?? process.stdin;
+  return Boolean(input?.isTTY);
+}
+
 export function applyPlacementDefaults(options, environment = {}) {
   const cwd = environment.cwd ? path.resolve(environment.cwd) : process.cwd();
   const resolved = cloneInitOptions(options);
@@ -494,6 +722,16 @@ async function readGitInfo(cwd) {
   }
 }
 
+async function readGitRoot(cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd });
+    const root = stdout.trim();
+    return root ? path.resolve(root) : null;
+  } catch {
+    return null;
+  }
+}
+
 async function discoverChildGitRepos(cwd) {
   let entries = [];
   try {
@@ -622,17 +860,7 @@ function writeAgentAdoptionPreview(prompter, candidates) {
 }
 
 function scanPotentialAgentWorkflowConflicts(content) {
-  const patterns = [
-    'session',
-    'handoff',
-    'decisions',
-    'wip.md',
-    'review handoff',
-    'close-session',
-    'address review',
-    'builder',
-    'reviewer',
-  ];
+  const patterns = getWorkflowConflictScanPatterns();
 
   return content
     .split(/\r?\n/)
@@ -1078,6 +1306,15 @@ async function directoryExists(directoryPath) {
   }
 }
 
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function isSameDirectory(left, right) {
   try {
     const [leftRealPath, rightRealPath] = await Promise.all([
@@ -1104,3 +1341,8 @@ function toRelativeIfInsideCwd(targetPath, cwd) {
 
   return relative;
 }
+
+function isPathInside(candidatePath, parentPath) {
+  const relative = path.relative(path.resolve(parentPath), path.resolve(candidatePath));
+  return Boolean(relative) && !relative.startsWith('..') && !path.isAbsolute(relative);
+}

package/src/status.js

@@ -0,0 +1,350 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { inspectProjectCompatibility } from './compatibility.js';
+import { parseSimpleYaml } from './simple-yaml.js';
+import { listProjectSessions } from './session.js';
+import { syncAgentInstructionFiles } from './generators/agent-files/index.js';
+
+export async function getProjectStatus(options = {}) {
+  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+  const rootDir = path.resolve(cwd, options.rootDir ?? '.compass');
+  const toolingRootDir = options.toolingRootDir
+    ? path.resolve(cwd, options.toolingRootDir)
+    : cwd;
+
+  const compatibility = await inspectProjectCompatibility({
+    rootDir,
+    cwd,
+    ...(options.packageVersion ? { packageVersion: options.packageVersion } : {}),
+  });
+  const [project, sessions, docsReview, agentFiles] = await Promise.all([
+    readProjectSummary(compatibility.projectFilePath),
+    readSessionsStatus(rootDir),
+    readDocsReviewStatus(rootDir),
+    readAgentFileStatus(rootDir, toolingRootDir),
+  ]);
+
+  return {
+    generatedAt: new Date().toISOString(),
+    rootDir,
+    toolingRootDir,
+    project,
+    compatibility: {
+      cliPackageVersion: compatibility.cliPackageVersion,
+      package: compatibility.package,
+      state: compatibility.state,
+      warnings: compatibility.warnings,
+    },
+    sessions,
+    docsReview,
+    agentFiles,
+    recommendations: buildRecommendations({
+      project,
+      compatibility,
+      sessions,
+      docsReview,
+      agentFiles,
+    }),
+  };
+}
+
+export function renderStatusText(status) {
+  if (status.project.status === 'unreadable') {
+    return [
+      'VibeCompass status',
+      `Status: not initialized`,
+      `Generated: ${status.generatedAt}`,
+      `Root: ${status.rootDir}`,
+      `Message: Not a VibeCompass project memory root. Run \`vibecompass init --guided\` to set one up.`,
+      '',
+      'Recommended next commands:',
+      '- vibecompass init --guided',
+      '',
+    ].join('\n');
+  }
+
+  const summary = hasStatusDrift(status) ? 'drift detected' : 'ok';
+  const lines = [
+    'VibeCompass status',
+    `Status: ${summary}`,
+    `Generated: ${status.generatedAt}`,
+    `Project: ${status.project.name ?? 'Unknown'}`,
+    `Mode: ${status.project.mode ?? 'Unknown'}`,
+    `Root: ${status.rootDir}`,
+    `Repos: ${status.project.repos.length > 0 ? status.project.repos.map((repo) => repo.id).join(', ') : 'None recorded'}`,
+    `Active lanes: ${formatActiveLanes(status.sessions)}`,
+    '',
+    'Package:',
+    `- CLI version: ${status.compatibility.cliPackageVersion}`,
+    `- Root stamp: ${formatPackageStatus(status.compatibility.package)}`,
+    ...(status.compatibility.state.packageObservedVersion
+      ? [`- Local observed: ${status.compatibility.state.packageObservedVersion} (from state/manifest.json)`]
+      : []),
+    `- State manifest: ${formatStateStatus(status.compatibility.state)}`,
+  ];
+
+  if (status.compatibility.warnings.length > 0) {
+    lines.push('', 'Warnings:');
+    for (const warning of status.compatibility.warnings) {
+      lines.push(`- ${warning.message}`);
+    }
+  }
+
+  lines.push(
+    '',
+    'Docs review:',
+    `- ${formatDocsReviewStatus(status.docsReview)}`,
+    '',
+    'Agent files:',
+    ...formatAgentFileStatus(status.agentFiles),
+  );
+
+  if (status.recommendations.length > 0) {
+    lines.push('', 'Recommended next commands:');
+    for (const recommendation of status.recommendations) {
+      lines.push(`- ${recommendation}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+export function toStatusJson(status) {
+  // Keep this as an explicit public-output shape. Nested status fields must
+  // remain free of raw manifests, preview tokens, and resolved env values.
+  return {
+    generatedAt: status.generatedAt,
+    rootDir: status.rootDir,
+    toolingRootDir: status.toolingRootDir,
+    project: status.project,
+    compatibility: status.compatibility,
+    sessions: status.sessions,
+    docsReview: status.docsReview,
+    agentFiles: status.agentFiles,
+    recommendations: status.recommendations,
+  };
+}
+
+async function readProjectSummary(projectFilePath) {
+  try {
+    const config = parseSimpleYaml(await readFile(projectFilePath, 'utf8'), {
+      sourceName: projectFilePath,
+    });
+    return {
+      status: 'ok',
+      name: typeof config.name === 'string' ? config.name : null,
+      mode: typeof config.mode === 'string' ? config.mode : null,
+      repos: Array.isArray(config.repos)
+        ? config.repos
+            .filter((repo) => repo && typeof repo === 'object')
+            .map((repo) => ({
+              id: typeof repo.id === 'string' ? repo.id : null,
+              remote: typeof repo.remote === 'string' ? repo.remote : null,
+              defaultBranch: typeof repo.default_branch === 'string' ? repo.default_branch : null,
+            }))
+            .filter((repo) => repo.id)
+        : [],
+      sync: config.sync && typeof config.sync === 'object'
+        ? {
+            provider: typeof config.sync.provider === 'string' ? config.sync.provider : null,
+            apiUrl: typeof config.sync.api_url === 'string' ? config.sync.api_url : null,
+            projectId: typeof config.sync.project_id === 'string' ? config.sync.project_id : null,
+            credentialSource: typeof config.sync.credential_source === 'string' ? config.sync.credential_source : null,
+            credentialEnvVar: typeof config.sync.credential_env_var === 'string' ? config.sync.credential_env_var : null,
+          }
+        : null,
+    };
+  } catch (error) {
+    return {
+      status: 'unreadable',
+      name: null,
+      mode: null,
+      repos: [],
+      sync: null,
+      errorMessage: error instanceof Error ? error.message : 'Unable to read project.yaml.',
+    };
+  }
+}
+
+async function readSessionsStatus(rootDir) {
+  try {
+    const sessions = await listProjectSessions({ rootDir });
+    return {
+      status: 'ok',
+      current: sessions.current,
+      lanes: sessions.lanes.map((lane) => ({
+        id: lane.id,
+        status: lane.status,
+        workingOn: lane.workingOn,
+      })),
+    };
+  } catch (error) {
+    return {
+      status: 'unreadable',
+      current: null,
+      lanes: [],
+      errorMessage: error instanceof Error ? error.message : 'Unable to read active sessions.',
+    };
+  }
+}
+
+async function readDocsReviewStatus(rootDir) {
+  const markerPath = path.join(rootDir, 'state', 'docs-review.json');
+  try {
+    const marker = JSON.parse(await readFile(markerPath, 'utf8'));
+    return {
+      status: typeof marker.status === 'string' ? marker.status : 'unknown',
+      markerPath,
+      completedAt: typeof marker.completed_at === 'string' ? marker.completed_at : null,
+      provider: typeof marker.provider === 'string' ? marker.provider : null,
+      model: typeof marker.model === 'string' ? marker.model : null,
+    };
+  } catch (error) {
+    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+      return {
+        status: 'missing',
+        markerPath,
+      };
+    }
+
+    return {
+      status: 'unreadable',
+      markerPath,
+      errorMessage: error instanceof Error ? error.message : 'Unable to read docs-review marker.',
+    };
+  }
+}
+
+async function readAgentFileStatus(rootDir, toolingRootDir) {
+  try {
+    const result = await syncAgentInstructionFiles({
+      rootDir,
+      toolingRootDir,
+      dryRun: true,
+    });
+    return {
+      status: 'ok',
+      dryRun: true,
+      results: result.results.map((item) => ({
+        format: item.format,
+        relativePath: item.relativePath,
+        status: item.status,
+        warning: item.warning,
+        changed: item.changed,
+        conflicts: item.conflicts ?? [],
+      })),
+    };
+  } catch (error) {
+    return {
+      status: 'unavailable',
+      dryRun: true,
+      results: [],
+      errorMessage: error instanceof Error ? error.message : 'Unable to inspect agent files.',
+    };
+  }
+}
+
+function buildRecommendations({ project, compatibility, sessions, docsReview, agentFiles }) {
+  const recommendations = [];
+  if (project.status === 'unreadable') {
+    recommendations.push('vibecompass init --guided');
+    return recommendations;
+  }
+
+  const packageStatus = compatibility.package.status;
+  const stateStatus = compatibility.state.status;
+  if (['legacy', 'behind', 'ahead', 'invalid'].includes(packageStatus) || ['missing', 'unreadable', 'unsupported'].includes(stateStatus)) {
+    recommendations.push('vibecompass refresh-workflow --dry-run');
+  }
+
+  if (docsReview.status === 'missing') {
+    recommendations.push('vibecompass docs-review --guided');
+  }
+
+  if (agentFiles.status === 'ok' && agentFiles.results.some((item) => item.changed || item.warning)) {
+    recommendations.push('vibecompass sync-agents --dry-run');
+  }
+
+  if (sessions.status === 'ok' && sessions.lanes.length === 0) {
+    recommendations.push('vibecompass start-session --id LANE_ID --working-on "TASK"');
+  } else if (sessions.status === 'ok' && sessions.lanes.length >= 2) {
+    recommendations.push('vibecompass list-sessions');
+  }
+
+  return [...new Set(recommendations)];
+}
+
+function hasStatusDrift(status) {
+  return (
+    status.compatibility.warnings.length > 0 ||
+    status.docsReview.status !== 'completed' ||
+    status.agentFiles.status !== 'ok' ||
+    status.agentFiles.results.some((item) => item.changed || item.warning)
+  );
+}
+
+function formatActiveLanes(sessions) {
+  if (sessions.status !== 'ok') {
+    return `unavailable (${sessions.errorMessage})`;
+  }
+
+  if (sessions.lanes.length === 0) {
+    return 'none';
+  }
+
+  return `${sessions.lanes.length}${sessions.current ? ` (current: ${sessions.current})` : ''}`;
+}
+
+function formatPackageStatus(packageStatus) {
+  if (packageStatus.status === 'legacy') {
+    return 'legacy/unknown';
+  }
+  if (packageStatus.status === 'unknown') {
+    return `unknown (${packageStatus.errorMessage})`;
+  }
+  if (packageStatus.status === 'invalid') {
+    return `invalid (${String(packageStatus.rootVersion)})`;
+  }
+  return `${packageStatus.rootVersion ?? 'none'} (${packageStatus.status})`;
+}
+
+function formatStateStatus(stateStatus) {
+  if (stateStatus.status === 'current') {
+    return `state_version ${stateStatus.observedVersion} (current)`;
+  }
+  if (stateStatus.status === 'unsupported') {
+    return `state_version ${stateStatus.observedVersion ?? 'missing'} (unsupported; expected ${stateStatus.expectedVersion})`;
+  }
+  if (stateStatus.status === 'unreadable') {
+    return `unreadable (${stateStatus.errorMessage})`;
+  }
+  if (stateStatus.status === 'missing') {
+    return 'no manifest yet (will be created on first command that writes state)';
+  }
+  return stateStatus.status;
+}
+
+function formatDocsReviewStatus(docsReview) {
+  if (docsReview.status === 'missing') {
+    return 'No docs-review marker found';
+  }
+  if (docsReview.status === 'unreadable') {
+    return `Marker unreadable (${docsReview.errorMessage})`;
+  }
+  return `${docsReview.status}${docsReview.completedAt ? ` at ${docsReview.completedAt}` : ''}`;
+}
+
+function formatAgentFileStatus(agentFiles) {
+  if (agentFiles.status !== 'ok') {
+    return [`- unavailable (${agentFiles.errorMessage})`];
+  }
+
+  if (agentFiles.results.length === 0) {
+    return ['- none configured'];
+  }
+
+  return agentFiles.results.map((item) => {
+    const warning = item.warning ? ` — ${item.warning}` : '';
+    return `- ${item.relativePath}: ${item.status}${warning}`;
+  });
+}

package/src/version.js

@@ -0,0 +1,6 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+
+export const PACKAGE_VERSION = packageJson.version;