@vibecompass/vibecompass 0.3.0 → 0.3.3

package/src/project-memory.js

@@ -468,8 +468,23 @@ function parseDecisionDocument(options) {
   const warnings = [];
   const errors = [];
   const entries = extractDecisionEntries(options.content);
+  const malformedHeadings = extractMalformedDecisionHeadings(options.content);
+
+  for (const heading of malformedHeadings) {
+    errors.push(
+      createError(
+        options.relativePath,
+        'decision-invalid-id',
+        `Decision heading "${heading}" must use zero-padded D-NNN or higher.`,
+      ),
+    );
+  }
 
   if (entries.length === 0) {
+    if (malformedHeadings.length > 0) {
+      return { kind: 'decision', extracted: null, warnings, errors };
+    }
+
     errors.push(
       createError(options.relativePath, 'decision-missing-entries', 'Decision files must contain at least one resolvable decision entry.'),
     );
@@ -479,7 +494,7 @@ function parseDecisionDocument(options) {
   const decisionIds = [];
   for (const entry of entries) {
     if (!entry.decisionId || entry.decisionId <= 0) {
-      errors.push(createError(options.relativePath, 'decision-invalid-id', 'Decision heading must include D-<positive integer>.'));
+      errors.push(createError(options.relativePath, 'decision-invalid-id', 'Decision heading must include zero-padded D-<NNN>.'));
       continue;
     }
 
@@ -576,7 +591,7 @@ function parseSessionDocument(options) {
 }
 
 function extractDecisionEntries(content) {
-  const matches = [...content.matchAll(/^###\s+D-(\d+)\b.*$/gm)];
+  const matches = [...content.matchAll(/^###\s+D-(\d{3,})\b.*$/gm)];
 
   return matches.map((match, index) => {
     const bodyStart = match.index ?? 0;
@@ -590,6 +605,10 @@ function extractDecisionEntries(content) {
   });
 }
 
+function extractMalformedDecisionHeadings(content) {
+  return [...content.matchAll(/^###\s+(D-\d{1,2})\b.*$/gm)].map((match) => match[1]);
+}
+
 function findDuplicateDecisionErrors(documents) {
   const seen = new Map();
   const errors = [];

package/src/read-model.js

@@ -5,7 +5,7 @@ import { generateStateManifest } from './manifest.js';
 import { scanProjectMemory } from './project-memory.js';
 
 const SECTION_PATTERN = /^##\s+(.+)$/gm;
-const DECISION_HEADING_PATTERN = /^###\s+D-(\d+)\s+—\s+(.+)$/gm;
+const DECISION_HEADING_PATTERN = /^###\s+D-(\d{3,})\s+—\s+(.+)$/gm;
 
 export async function loadProjectReadModel(rootDir) {
   const scanResult = await scanProjectMemory(rootDir);

package/src/setup.js

@@ -1,6 +1,10 @@
-import { access } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { access, readFile, readdir, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
 
 export const PLACEMENT_PATTERNS = {
   WORKSPACE_ROOT: 'workspace-root',
@@ -73,6 +77,40 @@ export async function resolveInitCliOptions(options, environment = {}) {
   };
 }
 
+export async function resolveConnectHostedCliOptions(options, environment = {}) {
+  const cwd = environment.cwd ? path.resolve(environment.cwd) : process.cwd();
+  let resolved = {
+    ...options,
+    sync: isPlainObject(options?.sync) ? { ...options.sync } : {},
+  };
+
+  if (!resolved.sync.apiUrl || !resolved.sync.projectId || !resolved.sync.credentialEnvVar) {
+    const prompter = createPrompter(environment.io, environment.runtime);
+    try {
+      if (!resolved.sync.apiUrl) {
+        resolved.sync.apiUrl = await askInput(prompter, 'Hosted sync API URL', {
+          defaultValue: 'https://vibecompass.dev',
+        });
+      }
+      if (!resolved.sync.projectId) {
+        resolved.sync.projectId = await askInput(prompter, 'Hosted project id');
+      }
+      if (!resolved.sync.credentialEnvVar) {
+        resolved.sync.credentialEnvVar = await askInput(prompter, 'Credential env var', {
+          defaultValue: 'VIBECOMPASS_SYNC_TOKEN',
+        });
+      }
+    } finally {
+      await prompter.close();
+    }
+  }
+
+  return {
+    rootDir: resolved.rootDir ? toRelativeIfInsideCwd(resolved.rootDir, cwd) : undefined,
+    sync: resolved.sync,
+  };
+}
+
 export function applyPlacementDefaults(options, environment = {}) {
   const cwd = environment.cwd ? path.resolve(environment.cwd) : process.cwd();
   const resolved = cloneInitOptions(options);
@@ -153,7 +191,8 @@ async function completeGuidedInitOptions(options, environment) {
   let resolved = cloneInitOptions(options);
   const cwd = environment.cwd;
   const prompter = environment.prompter;
-  const projectNameDefault = path.basename(cwd);
+  const inferredProject = await inferProjectFromCwd(cwd);
+  const projectNameDefault = inferredProject.projectName ?? path.basename(cwd);
 
   if (!resolved.name) {
     resolved.name = await askInput(prompter, 'Project name', {
@@ -162,63 +201,96 @@ async function completeGuidedInitOptions(options, environment) {
   }
 
   if (!resolved.mode) {
-    resolved.mode = await askChoice(prompter, 'Project mode', [
+    const setupGoal = await askChoice(prompter, 'What should VibeCompass set up?', [
       {
-        value: 'local-only',
-        description: 'Local files only. No hosted dependency.',
+        value: 'share-later',
+        description: 'Recommended. Local notes, with the option to share or collaborate later.',
       },
       {
-        value: 'local-primary',
-        description: 'Local files stay authoritative, with optional hosted sync/projection.',
+        value: 'local-only',
+        description: 'Local files only. No hosted sync or hosted docs-review prompts.',
       },
       {
         value: 'hosted-only',
-        description: 'Compatibility mode when hosted state remains authoritative.',
+        description: 'Hosted VibeCompass is already the source of truth for this project.',
       },
     ], {
-      defaultValue: 'local-only',
+      defaultValue: 'share-later',
     });
+    resolved.mode = setupGoal === 'share-later' ? 'local-primary' : setupGoal;
   }
 
+  const detectedRepos = inferredProject.repos ?? [];
+
   if (!Array.isArray(resolved.repos) || resolved.repos.length === 0) {
-    resolved.repos = await promptForRepos(prompter, cwd);
+    if (detectedRepos.length > 0) {
+      const useDetectedRepos = await askConfirm(
+        prompter,
+        formatDetectedReposPrompt(detectedRepos),
+        true,
+      );
+      resolved.repos = useDetectedRepos
+        ? detectedRepos.map((repo) => toProjectRepo(repo))
+        : await promptForRepos(prompter, cwd);
+    } else {
+      resolved.repos = await promptForRepos(prompter, cwd);
+    }
   }
 
   let recommendation = null;
   if (!resolved.placementPattern) {
-    recommendation = await promptForPlacement(prompter, {
-      cwd,
-      repoCount: resolved.repos.length,
-    });
-    resolved.placementPattern = recommendation.pattern;
+    if (inferredProject.source === 'child-repos' && detectedRepos.length > 1 && reposMatchDetected(resolved.repos, detectedRepos)) {
+      recommendation = recommendPlacementPattern({
+        repoCount: detectedRepos.length,
+        usesSharedWorkspace: true,
+      });
+      resolved.placementPattern = recommendation.pattern;
+      prompter.write(`Recommended placement: ${recommendation.pattern}\n`);
+      prompter.write(`${recommendation.reason}\n`);
+    } else if (detectedRepos.length === 1 && reposMatchDetected(resolved.repos, detectedRepos)) {
+      recommendation = recommendPlacementPattern({ repoCount: 1 });
+      resolved.placementPattern = recommendation.pattern;
+    } else {
+      recommendation = await promptForPlacement(prompter, {
+        cwd,
+        repoCount: resolved.repos.length,
+      });
+      resolved.placementPattern = recommendation.pattern;
+    }
   }
 
   if (!resolved.toolingRootDir) {
-    const ownerLabel = describePlacementOwner(resolved.placementPattern);
-    const defaultOwnerDir = await suggestOwnerDirectory({
-      cwd,
-      placementPattern: resolved.placementPattern,
-      repos: resolved.repos,
-    });
-    resolved.toolingRootDir = await askInput(prompter, ownerLabel, {
-      defaultValue: defaultOwnerDir,
-      validate: async (value) => {
-        if (!(await directoryExists(path.resolve(cwd, value)))) {
-          return `${ownerLabel} must already exist relative to the current working directory.`;
-        }
-
-        return null;
-      },
-    });
+    if (resolved.placementPattern === PLACEMENT_PATTERNS.PRIMARY_REPO && detectedRepos.length === 1 && reposMatchDetected(resolved.repos, detectedRepos)) {
+      resolved.toolingRootDir = detectedRepos[0].directory;
+    } else if (resolved.placementPattern === PLACEMENT_PATTERNS.WORKSPACE_ROOT && inferredProject.source === 'child-repos' && detectedRepos.length > 1 && reposMatchDetected(resolved.repos, detectedRepos)) {
+      resolved.toolingRootDir = '.';
+    } else {
+      const ownerLabel = describePlacementOwner(resolved.placementPattern);
+      const defaultOwnerDir = await suggestOwnerDirectory({
+        cwd,
+        placementPattern: resolved.placementPattern,
+        repos: resolved.repos,
+      });
+      resolved.toolingRootDir = await askInput(prompter, ownerLabel, {
+        defaultValue: defaultOwnerDir,
+        validate: async (value) => {
+          if (!(await directoryExists(path.resolve(cwd, value)))) {
+            return `${ownerLabel} must already exist relative to the current working directory.`;
+          }
+
+          return null;
+        },
+      });
+    }
   }
 
   resolved = applyPlacementDefaults(resolved, { cwd });
 
-  if (!resolved.sync && resolved.mode === 'local-primary') {
+  if (!resolved.sync && resolved.mode === 'hosted-only') {
     const configureSync = await askConfirm(
       prompter,
-      'Configure hosted sync binding now?',
-      false,
+      'Connect hosted VibeCompass now?',
+      resolved.mode === 'hosted-only',
     );
 
     if (configureSync) {
@@ -322,6 +394,170 @@ async function completeGuidedInitOptions(options, environment) {
   };
 }
 
+async function inferProjectFromCwd(cwd) {
+  const [packageName, gitInfo, childRepos] = await Promise.all([
+    readPackageName(cwd),
+    readGitInfo(cwd),
+    discoverChildGitRepos(cwd),
+  ]);
+  const projectName = packageName ?? path.basename(cwd);
+
+  if (gitInfo?.remote) {
+    const remoteSlug = extractRemoteSlug(gitInfo.remote);
+    const repoId = suggestRepoId(remoteSlug ?? packageName ?? path.basename(gitInfo.root ?? cwd));
+
+    return {
+      projectName,
+      source: 'current-repo',
+      repos: [
+        {
+          id: repoId,
+          remote: gitInfo.remote,
+          directory: '.',
+          ...(gitInfo.branch ? { defaultBranch: gitInfo.branch } : {}),
+        },
+      ],
+    };
+  }
+
+  if (childRepos.length > 0) {
+    return {
+      projectName,
+      source: 'child-repos',
+      repos: childRepos,
+    };
+  }
+
+  return {
+    projectName,
+    source: 'none',
+    repos: [],
+  };
+}
+
+async function readPackageName(cwd) {
+  try {
+    const packageJson = JSON.parse(await readFile(path.join(cwd, 'package.json'), 'utf8'));
+    return typeof packageJson.name === 'string' && packageJson.name.trim()
+      ? packageJson.name.trim()
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+async function readGitInfo(cwd) {
+  try {
+    const [{ stdout: remote }, { stdout: root }, branchResult] = await Promise.all([
+      execFileAsync('git', ['remote', 'get-url', 'origin'], { cwd }),
+      execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),
+      execFileAsync('git', ['branch', '--show-current'], { cwd }).catch(() => ({ stdout: '' })),
+    ]);
+    const normalizedRemote = remote.trim();
+    if (!normalizedRemote) {
+      return null;
+    }
+
+    return {
+      remote: normalizedRemote,
+      root: root.trim() || null,
+      branch: branchResult.stdout.trim() || null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function discoverChildGitRepos(cwd) {
+  let entries = [];
+  try {
+    entries = await readdir(cwd, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const candidates = entries
+    .filter((entry) => entry.isDirectory() && isScannableWorkspaceChild(entry.name))
+    .sort((left, right) => left.name.localeCompare(right.name));
+
+  const discovered = await Promise.all(candidates.map(async (entry) => {
+    const directory = entry.name;
+    const absoluteDirectory = path.join(cwd, directory);
+    const [gitInfo, packageName] = await Promise.all([
+      readGitInfo(absoluteDirectory),
+      readPackageName(absoluteDirectory),
+    ]);
+
+    if (!gitInfo?.remote) {
+      return null;
+    }
+
+    if (gitInfo.root && !(await isSameDirectory(gitInfo.root, absoluteDirectory))) {
+      return null;
+    }
+
+    const remoteSlug = extractRemoteSlug(gitInfo.remote);
+    return {
+      id: suggestRepoId(remoteSlug ?? packageName ?? directory),
+      remote: gitInfo.remote,
+      directory,
+      ...(gitInfo.branch ? { defaultBranch: gitInfo.branch } : {}),
+    };
+  }));
+
+  const reposByDirectory = new Map();
+  for (const repo of discovered) {
+    if (repo && !reposByDirectory.has(repo.directory)) {
+      reposByDirectory.set(repo.directory, repo);
+    }
+  }
+
+  return [...reposByDirectory.values()].sort((left, right) => left.directory.localeCompare(right.directory));
+}
+
+function isScannableWorkspaceChild(name) {
+  if (!name || name.startsWith('.')) {
+    return false;
+  }
+
+  return !new Set([
+    'build',
+    'coverage',
+    'dist',
+    'node_modules',
+    'out',
+    'target',
+    'vendor',
+  ]).has(name);
+}
+
+function formatDetectedReposPrompt(repos) {
+  if (repos.length === 1) {
+    const repo = repos[0];
+    const location = repo.directory && repo.directory !== '.' ? ` in ${repo.directory}` : '';
+    return `Use detected Git repo${location} (${repo.remote})?`;
+  }
+
+  return `Use ${repos.length} detected Git repos (${repos.map((repo) => repo.directory).join(', ')})?`;
+}
+
+function toProjectRepo(repo) {
+  return {
+    id: repo.id,
+    remote: repo.remote,
+    ...(repo.defaultBranch ? { defaultBranch: repo.defaultBranch } : {}),
+  };
+}
+
+function reposMatchDetected(repos, detectedRepos) {
+  if (!Array.isArray(repos) || repos.length !== detectedRepos.length) {
+    return false;
+  }
+
+  const detectedKeys = new Set(detectedRepos.map((repo) => `${repo.id}\n${repo.remote}`));
+  return repos.every((repo) => detectedKeys.has(`${repo.id}\n${repo.remote}`));
+}
+
 async function promptForRepos(prompter, cwd) {
   const repoCount = await askInteger(prompter, 'How many repos belong to this logical project?', {
     defaultValue: 1,
@@ -757,6 +993,18 @@ async function directoryExists(directoryPath) {
   }
 }
 
+async function isSameDirectory(left, right) {
+  try {
+    const [leftRealPath, rightRealPath] = await Promise.all([
+      realpath(left),
+      realpath(right),
+    ]);
+    return leftRealPath === rightRealPath;
+  } catch {
+    return path.resolve(left) === path.resolve(right);
+  }
+}
+
 function toRelativeIfInsideCwd(targetPath, cwd) {
   const absolute = path.resolve(cwd, targetPath);
   const relative = path.relative(cwd, absolute);