@vibecompass/vibecompass 0.3.1 → 0.3.3

package/README.md

@@ -327,11 +327,14 @@ Guided init can also record workflow defaults in
 `project.yaml.metadata.workflow`, including whether close-session should
 include a Git publish step and which remote name to use for that step.
 
-Guided init is inference-first for the common single-repo case: it reads
-`package.json`, detects the current Git `origin`, asks you to confirm the
-detected repo, and maps a friendly setup goal to the stored project mode.
-Hosted credentials are deferred by default; run `vibecompass connect-hosted`
-when you are ready to connect the local root to `vibecompass.dev`.
+Guided init is inference-first for common repo layouts: it reads `package.json`,
+detects the current Git `origin` when you run it inside a repo, or scans a
+parent workspace for immediate child repos when the parent is not itself a Git
+checkout. It asks once before using detected repos, maps a friendly setup goal
+to the stored project mode, places single-child repo memory under that child
+repo, and uses workspace-root placement for multi-repo parent folders. Hosted
+credentials are deferred by default; run `vibecompass connect-hosted` when you
+are ready to connect the local root to `vibecompass.dev`.
 
 ### `vibecompass connect-hosted`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecompass/vibecompass",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Local-first project-memory core for VibeCompass",
   "type": "module",
   "bin": {

package/src/setup.js

@@ -1,5 +1,5 @@
 import { execFile } from 'node:child_process';
-import { access, readFile } from 'node:fs/promises';
+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';
@@ -220,14 +220,18 @@ async function completeGuidedInitOptions(options, environment) {
     resolved.mode = setupGoal === 'share-later' ? 'local-primary' : setupGoal;
   }
 
+  const detectedRepos = inferredProject.repos ?? [];
+
   if (!Array.isArray(resolved.repos) || resolved.repos.length === 0) {
-    if (inferredProject.repo) {
-      const useDetectedRepo = await askConfirm(
+    if (detectedRepos.length > 0) {
+      const useDetectedRepos = await askConfirm(
         prompter,
-        `Use detected Git repo ${inferredProject.repo.remote}?`,
+        formatDetectedReposPrompt(detectedRepos),
         true,
       );
-      resolved.repos = useDetectedRepo ? [inferredProject.repo] : await promptForRepos(prompter, cwd);
+      resolved.repos = useDetectedRepos
+        ? detectedRepos.map((repo) => toProjectRepo(repo))
+        : await promptForRepos(prompter, cwd);
     } else {
       resolved.repos = await promptForRepos(prompter, cwd);
     }
@@ -235,7 +239,15 @@ async function completeGuidedInitOptions(options, environment) {
 
   let recommendation = null;
   if (!resolved.placementPattern) {
-    if (inferredProject.repo && resolved.repos.length === 1) {
+    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 {
@@ -248,7 +260,9 @@ async function completeGuidedInitOptions(options, environment) {
   }
 
   if (!resolved.toolingRootDir) {
-    if (inferredProject.repo && resolved.repos.length === 1 && resolved.placementPattern === PLACEMENT_PATTERNS.PRIMARY_REPO) {
+    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);
@@ -381,26 +395,43 @@ async function completeGuidedInitOptions(options, environment) {
 }
 
 async function inferProjectFromCwd(cwd) {
-  const [packageName, gitInfo] = await Promise.all([
+  const [packageName, gitInfo, childRepos] = await Promise.all([
     readPackageName(cwd),
     readGitInfo(cwd),
+    discoverChildGitRepos(cwd),
   ]);
   const projectName = packageName ?? path.basename(cwd);
 
-  if (!gitInfo?.remote) {
-    return { projectName, repo: null };
+  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 } : {}),
+        },
+      ],
+    };
   }
 
-  const remoteSlug = extractRemoteSlug(gitInfo.remote);
-  const repoId = suggestRepoId(remoteSlug ?? packageName ?? path.basename(gitInfo.root ?? cwd));
+  if (childRepos.length > 0) {
+    return {
+      projectName,
+      source: 'child-repos',
+      repos: childRepos,
+    };
+  }
 
   return {
     projectName,
-    repo: {
-      id: repoId,
-      remote: gitInfo.remote,
-      ...(gitInfo.branch ? { defaultBranch: gitInfo.branch } : {}),
-    },
+    source: 'none',
+    repos: [],
   };
 }
 
@@ -437,6 +468,96 @@ async function readGitInfo(cwd) {
   }
 }
 
+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,
@@ -872,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);