@wipcomputer/wip-repos 1.9.69 → 1.9.70

package/README.md

@@ -24,6 +24,10 @@ wip-repos check
 wip-repos check --all
 wip-repos check --class worktree
 
+# Report release-pipeline enrollment status
+wip-repos release-enrollment
+wip-repos release-enrollment --strict
+
 # See what sync would do
 wip-repos sync
 
@@ -46,6 +50,7 @@ wip-repos tree
 --manifest   Path to repos-manifest.json (default: ./repos-manifest.json)
 --root       Path to repos root directory (default: directory containing manifest)
 --dry-run    Show what would happen without making changes
+--strict     Treat missing release enrollment decisions as failures
 --json       Output as JSON
 ```
 
@@ -57,10 +62,37 @@ wip-repos tree
 
 3. **add/move** update the manifest file. The actual folder moves happen on the next `sync`.
 
+4. **release-enrollment** reports which active manifest repos are enrolled in the release pipeline, explicitly excluded, still need a release-profile decision, missing on disk, or active on disk but unmanifested. By default, missing repos and unmanifested active repos are blockers. With `--strict`, missing release decisions are blockers too.
+
+Release enrollment metadata lives in each manifest entry:
+
+```json
+{
+  "ldm-os/devops/my-tool-private": {
+    "remote": "wipcomputer/my-tool-private",
+    "release": {
+      "enabled": true,
+      "profile": "node-package",
+      "smokeProfile": "ldm-tool",
+      "publicMirror": "wipcomputer/my-tool",
+      "requiredSecrets": ["NPM_TOKEN"]
+    }
+  },
+  "ldm-os/docs/archive": {
+    "remote": "wipcomputer/docs-archive",
+    "release": {
+      "enabled": false,
+      "reason": "archived repo"
+    }
+  }
+}
+```
+
 ## Integration
 
 - `deploy-public` and `wip-release` can call `wip-repos check` before running. Stale manifest blocks deploys.
 - CI: run `wip-repos check` as a PR check. Drift = blocked merge.
+- CI/release planning: run `wip-repos release-enrollment --strict --json` to make release-owned repo enrollment machine-readable.
 - README generation: `wip-repos tree` outputs a directory tree from the manifest.
 
 ## Source

package/SKILL.md

@@ -39,6 +39,7 @@ Repo manifest reconciler. Like prettier for folder structure. Move folders aroun
 **Use wip-repos for:**
 - Checking if the filesystem matches the manifest (`check`)
 - Moving repos to match the manifest (`sync`)
+- Reporting release-pipeline enrollment state (`release-enrollment`)
 - Adding a new repo to the manifest (`add`)
 - Moving a repo in the manifest (`move`)
 - Generating a directory tree from the manifest (`tree`)
@@ -61,6 +62,8 @@ Repo manifest reconciler. Like prettier for folder structure. Move folders aroun
 wip-repos check                              # diff filesystem vs manifest
 wip-repos check --all                        # include worktrees/trash/archive paths
 wip-repos check --class worktree             # inspect one lifecycle class
+wip-repos release-enrollment                 # report release enrollment decisions
+wip-repos release-enrollment --strict --json # CI-ready enrollment gate
 wip-repos sync                               # preview moves
 wip-repos sync --apply                       # execute safe moves
 wip-repos add ldm-os/utilities/new-tool --remote wipcomputer/new-tool
@@ -71,9 +74,10 @@ wip-repos tree                               # generate directory tree
 ### Module
 
 ```javascript
-import { check, planSync, addRepo, moveRepo, generateReadmeTree } from '@wipcomputer/wip-repos';
+import { check, releaseEnrollment, planSync, addRepo, moveRepo, generateReadmeTree } from '@wipcomputer/wip-repos';
 
 const result = check('/path/to/manifest.json', '/path/to/repos/');
+const enrollment = releaseEnrollment('/path/to/manifest.json', '/path/to/repos/', { strict: true });
 const moves = planSync('/path/to/manifest.json', '/path/to/repos/');
 ```
 
@@ -81,4 +85,4 @@ const moves = planSync('/path/to/manifest.json', '/path/to/repos/');
 
 ### MCP
 
-Tools: `repos_check`, `repos_sync_plan`, `repos_add`, `repos_move`, `repos_tree`
+Tools: `repos_check`, `repos_release_enrollment`, `repos_sync_plan`, `repos_add`, `repos_move`, `repos_tree`

package/cli.mjs

@@ -11,7 +11,7 @@
  *   tree    - Generate directory tree from manifest
  */
 
-import { check, planSync, executeSync, addRepo, moveRepo, generateReadmeTree, loadManifest, checkCompliance, fixCompliance, findUnmanifested } from './core.mjs';
+import { check, planSync, executeSync, addRepo, moveRepo, generateReadmeTree, loadManifest, checkCompliance, fixCompliance, findUnmanifested, releaseEnrollment } from './core.mjs';
 import { runClaude } from './claude.mjs';
 import { resolve, dirname, join } from 'node:path';
 import { readFileSync } from 'node:fs';
@@ -35,6 +35,7 @@ Usage:
   wip-repos sync       [--manifest path] [--root path] [--apply]
   wip-repos compliance [--manifest path] [--root path] [--fix]
   wip-repos watchdog   [--manifest path] [--root path]
+  wip-repos release-enrollment [--manifest path] [--root path] [--strict]
   wip-repos add <path> --remote <org/repo> [--category cat] [--description desc]
   wip-repos move <path> --to <new-path>
   wip-repos tree       [--manifest path]
@@ -44,6 +45,8 @@ Commands:
   sync         Move local folders to match the manifest
   compliance   Check all repos for .license-guard.json, LICENSE, CLA.md, .npmignore
   watchdog     Find repos on disk that are not in the manifest
+  release-enrollment
+               Report release-pipeline enrollment decisions for active repos
   add          Add a repo to the manifest
   move         Move a repo to a different category in the manifest
   tree         Generate directory tree from manifest
@@ -53,6 +56,7 @@ Options:
   --root       Path to repos root directory (default: directory containing manifest)
   --all        Include worktrees, trash, archived, and other ignored lifecycle paths
   --class      Show one lifecycle class only (active, worktree, trash, sort, sunsetted, archived, third-party)
+  --strict     Treat missing release enrollment decisions as failures
   --apply      Apply sync moves. Without this, sync is a dry run
   --fix        Create missing compliance files (with compliance command)
   --json       Output as JSON`);
@@ -265,6 +269,80 @@ try {
       break;
     }
 
+    case 'release-enrollment': {
+      const result = releaseEnrollment(manifestPath, reposRoot, {
+        strict: hasFlag('--strict'),
+      });
+
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.clean) process.exit(1);
+        break;
+      }
+
+      console.log('Release enrollment inventory');
+      console.log(`Active manifest repos: ${result.summary.manifestActive}`);
+      console.log(`Enrolled:              ${result.summary.enrolled}`);
+      console.log(`Excluded:              ${result.summary.excluded}`);
+      console.log(`Needs decision:        ${result.summary.needsDecision}`);
+      console.log(`Missing on disk:       ${result.summary.missingOnDisk}`);
+      console.log(`Unmanifested active:   ${result.summary.unmanifestedActive}`);
+      console.log(`Blockers:              ${result.summary.blockers}`);
+      console.log();
+
+      if (result.enrolled.length > 0) {
+        console.log(`ENROLLED (${result.enrolled.length}):`);
+        for (const entry of result.enrolled) {
+          const profile = entry.profile ? ` profile=${entry.profile}` : '';
+          const pkg = entry.packageName ? ` package=${entry.packageName}` : '';
+          const issues = entry.issues?.length ? ` issues=${entry.issues.join('; ')}` : '';
+          console.log(`  ✓ ${entry.path}${profile}${pkg}${issues}`);
+        }
+        console.log();
+      }
+
+      if (result.excluded.length > 0) {
+        console.log(`EXCLUDED (${result.excluded.length}):`);
+        for (const entry of result.excluded) {
+          console.log(`  - ${entry.path}: ${entry.reason}`);
+        }
+        console.log();
+      }
+
+      if (result.needsDecision.length > 0) {
+        const mode = result.strict ? 'BLOCKING because --strict is set' : 'NON-BLOCKING without --strict';
+        console.log(`NEEDS DECISION (${result.needsDecision.length}, ${mode}):`);
+        for (const entry of result.needsDecision) {
+          console.log(`  ? ${entry.path}: ${entry.issue}`);
+        }
+        console.log();
+      }
+
+      if (result.missingOnDisk.length > 0) {
+        console.log(`MISSING ON DISK (${result.missingOnDisk.length}):`);
+        for (const entry of result.missingOnDisk) {
+          console.log(`  ! ${entry.path}: ${entry.issue}`);
+        }
+        console.log();
+      }
+
+      if (result.unmanifestedActive.length > 0) {
+        console.log(`UNMANIFESTED ACTIVE (${result.unmanifestedActive.length}):`);
+        for (const entry of result.unmanifestedActive) {
+          console.log(`  + ${entry.path}: ${entry.reason}`);
+        }
+        console.log();
+      }
+
+      if (result.clean) {
+        console.log('Release enrollment inventory is actionable.');
+      } else {
+        console.log('Release enrollment inventory has blockers.');
+        process.exit(1);
+      }
+      break;
+    }
+
     case 'claude': {
       runClaude(manifestPath, args.slice(1));
       break;

package/core.mjs

@@ -491,3 +491,145 @@ export function findUnmanifested(manifestPath, reposRoot) {
   const result = check(manifestPath, reposRoot);
   return result.onDiskOnly;
 }
+
+function readPackageInfo(fullPath) {
+  const packagePath = join(fullPath, 'package.json');
+  if (!existsSync(packagePath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+    return {
+      name: pkg.name || null,
+      version: pkg.version || null,
+      private: Boolean(pkg.private),
+      scripts: pkg.scripts || {},
+    };
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
+function getReleaseConfig(info) {
+  if (!info || typeof info !== 'object') return {};
+  if (info.release && typeof info.release === 'object') return info.release;
+  if (info.ci && typeof info.ci === 'object' && info.ci.release && typeof info.ci.release === 'object') {
+    return info.ci.release;
+  }
+  return {};
+}
+
+function isReleaseExcluded(releaseConfig) {
+  return releaseConfig.enabled === false || releaseConfig.enrolled === false;
+}
+
+function isReleaseEnrolled(releaseConfig) {
+  return releaseConfig.enabled === true || releaseConfig.enrolled === true || Boolean(releaseConfig.profile);
+}
+
+/**
+ * Report release-pipeline enrollment status for active manifest repos.
+ *
+ * This intentionally reuses the manifest and filesystem classifier from check().
+ * It answers the Phase 0 release-pipeline question: which repos are enrolled,
+ * which are explicitly excluded, and which still need a release-profile decision.
+ */
+export function releaseEnrollment(manifestPath, reposRoot, opts = {}) {
+  const manifest = loadManifest(manifestPath);
+  const inventory = check(manifestPath, reposRoot);
+  const strict = Boolean(opts.strict);
+
+  const enrolled = [];
+  const excluded = [];
+  const needsDecision = [];
+  const missingOnDisk = [];
+
+  for (const [repoPath, info] of Object.entries(manifest.repos)) {
+    const classification = classifyRepoPath(repoPath, join(reposRoot, repoPath));
+    if (classification.class !== 'active') continue;
+
+    const fullPath = join(reposRoot, repoPath);
+    const exists = existsSync(fullPath);
+    const releaseConfig = getReleaseConfig(info);
+    const packageInfo = exists ? readPackageInfo(fullPath) : null;
+    const entry = {
+      path: repoPath,
+      remote: info.remote || null,
+      packageName: packageInfo?.name || releaseConfig.packageName || releaseConfig.npmPackage || null,
+      packageVersion: packageInfo?.version || null,
+      profile: releaseConfig.profile || null,
+      smokeProfile: releaseConfig.smokeProfile || null,
+      publicMirror: releaseConfig.publicMirror || info.public || null,
+      requiredSecrets: Array.isArray(releaseConfig.requiredSecrets) ? releaseConfig.requiredSecrets : [],
+      scripts: packageInfo?.scripts ? Object.keys(packageInfo.scripts).sort() : [],
+    };
+
+    if (!exists) {
+      missingOnDisk.push({
+        ...entry,
+        issue: 'manifest entry is active but repo is not on disk',
+      });
+      continue;
+    }
+
+    if (packageInfo?.error) {
+      needsDecision.push({
+        ...entry,
+        issue: `package.json is invalid: ${packageInfo.error}`,
+      });
+      continue;
+    }
+
+    if (isReleaseExcluded(releaseConfig)) {
+      excluded.push({
+        ...entry,
+        reason: releaseConfig.reason || releaseConfig.excludeReason || 'release enrollment explicitly disabled',
+      });
+      continue;
+    }
+
+    if (isReleaseEnrolled(releaseConfig)) {
+      const issues = [];
+      if (!entry.profile) issues.push('missing release.profile');
+      if (!entry.packageName && packageInfo) issues.push('missing package name');
+      enrolled.push({ ...entry, issues });
+      continue;
+    }
+
+    needsDecision.push({
+      ...entry,
+      issue: 'missing release enrollment decision',
+    });
+  }
+
+  const unmanifestedActive = inventory.onDiskOnlyDetails
+    .filter(entry => entry.class === 'active')
+    .map(entry => ({
+      path: entry.path,
+      reason: entry.reason,
+    }));
+
+  const blockers = [
+    ...missingOnDisk.map(entry => ({ type: 'missing-on-disk', path: entry.path, issue: entry.issue })),
+    ...unmanifestedActive.map(entry => ({ type: 'unmanifested-active', path: entry.path, issue: entry.reason })),
+    ...(strict ? needsDecision.map(entry => ({ type: 'needs-decision', path: entry.path, issue: entry.issue })) : []),
+  ].sort((a, b) => a.path.localeCompare(b.path));
+
+  return {
+    strict,
+    clean: blockers.length === 0,
+    summary: {
+      manifestActive: enrolled.length + excluded.length + needsDecision.length + missingOnDisk.length,
+      enrolled: enrolled.length,
+      excluded: excluded.length,
+      needsDecision: needsDecision.length,
+      missingOnDisk: missingOnDisk.length,
+      unmanifestedActive: unmanifestedActive.length,
+      blockers: blockers.length,
+    },
+    enrolled: enrolled.sort((a, b) => a.path.localeCompare(b.path)),
+    excluded: excluded.sort((a, b) => a.path.localeCompare(b.path)),
+    needsDecision: needsDecision.sort((a, b) => a.path.localeCompare(b.path)),
+    missingOnDisk: missingOnDisk.sort((a, b) => a.path.localeCompare(b.path)),
+    unmanifestedActive,
+    blockers,
+  };
+}

package/mcp-server.mjs

@@ -7,7 +7,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import {
-  check, planSync, addRepo, moveRepo, generateReadmeTree,
+  check, planSync, addRepo, moveRepo, generateReadmeTree, releaseEnrollment,
 } from './core.mjs';
 
 const server = new Server(
@@ -43,6 +43,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ['manifestPath', 'reposRoot'],
       },
     },
+    {
+      name: 'repos_release_enrollment',
+      description: 'Report release-pipeline enrollment status for active manifest repos: enrolled, excluded, needs decision, missing on disk, and unmanifested active repos.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+          reposRoot: { type: 'string', description: 'Root directory containing repos' },
+          strict: { type: 'boolean', description: 'Treat repos missing release enrollment decisions as blockers' },
+        },
+        required: ['manifestPath', 'reposRoot'],
+      },
+    },
     {
       name: 'repos_add',
       description: 'Add a repo to the manifest.',
@@ -112,6 +125,19 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       };
     }
 
+    if (name === 'repos_release_enrollment') {
+      const result = releaseEnrollment(args.manifestPath, args.reposRoot, {
+        strict: Boolean(args.strict),
+      });
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        }],
+        isError: !result.clean,
+      };
+    }
+
     if (name === 'repos_add') {
       const entry = addRepo(args.manifestPath, args.repoPath, args.remote, {
         description: args.description,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/wip-repos",
-  "version": "1.9.69",
+  "version": "1.9.70",
   "type": "module",
   "description": "Repo manifest reconciler. Single source of truth for repo organization. Like prettier for folder structure.",
   "main": "core.mjs",

package/test.mjs

@@ -3,7 +3,7 @@ import { execSync } from 'node:child_process';
 import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { check, executeSync, planSync } from './core.mjs';
+import { check, executeSync, planSync, releaseEnrollment } from './core.mjs';
 
 function run(cmd, cwd) {
   execSync(cmd, { cwd, stdio: 'ignore' });
@@ -22,6 +22,8 @@ const root = mkdtempSync(join(tmpdir(), 'wip-repos-test-'));
 const manifestPath = join(root, 'repos-manifest.json');
 
 initRepo(join(root, 'active/repo-a'), 'wipcomputer/repo-a');
+initRepo(join(root, 'active/repo-b'), 'wipcomputer/repo-b');
+initRepo(join(root, 'active/no-decision'), 'wipcomputer/no-decision');
 initRepo(join(root, '_trash/old-repo'), 'wipcomputer/old-repo');
 initRepo(join(root, 'active/misplaced'), 'wipcomputer/right-place');
 mkdirSync(join(root, '.worktrees'), { recursive: true });
@@ -29,8 +31,19 @@ run(`git worktree add -q -b feat ${join(root, '.worktrees/repo-a--feat')}`, join
 
 writeFileSync(manifestPath, JSON.stringify({
   _format: 'v2',
-  'active/repo-a': { remote: 'wipcomputer/repo-a' },
-  'active/right-place': { remote: 'wipcomputer/right-place' },
+  'active/repo-a': {
+    remote: 'wipcomputer/repo-a',
+    release: { enabled: true, profile: 'node-package', smokeProfile: 'none' },
+  },
+  'active/repo-b': {
+    remote: 'wipcomputer/repo-b',
+    release: { enabled: false, reason: 'docs-only fixture' },
+  },
+  'active/no-decision': { remote: 'wipcomputer/no-decision' },
+  'active/right-place': {
+    remote: 'wipcomputer/right-place',
+    release: { enabled: true, profile: 'node-package' },
+  },
 }, null, 2) + '\n');
 
 const defaultCheck = check(manifestPath, root);
@@ -54,6 +67,28 @@ if (worktreeCheck.disk.length !== 1 || worktreeCheck.disk[0].class !== 'worktree
   throw new Error('--class worktree should return only worktrees');
 }
 
+const enrollment = releaseEnrollment(manifestPath, root);
+if (enrollment.summary.enrolled !== 1 || enrollment.summary.excluded !== 1) {
+  throw new Error('releaseEnrollment should count enrolled and excluded repos');
+}
+if (enrollment.summary.needsDecision !== 1) {
+  throw new Error('releaseEnrollment should count repos without release decisions');
+}
+if (enrollment.summary.blockers !== 2) {
+  throw new Error('releaseEnrollment should block on missing and unmanifested active repos by default');
+}
+if (!enrollment.missingOnDisk.some(r => r.path === 'active/right-place')) {
+  throw new Error('releaseEnrollment should report active manifest repos missing on disk');
+}
+if (!enrollment.unmanifestedActive.some(r => r.path === 'active/misplaced')) {
+  throw new Error('releaseEnrollment should report active repos on disk but not in manifest');
+}
+
+const strictEnrollment = releaseEnrollment(manifestPath, root, { strict: true });
+if (strictEnrollment.summary.blockers !== 3) {
+  throw new Error('releaseEnrollment --strict should make missing decisions blocking');
+}
+
 const moves = planSync(manifestPath, root);
 if (moves.length !== 1 || moves[0].to !== 'active/right-place') {
   throw new Error('planSync should plan the misplaced active repo only');