@wipcomputer/wip-ai-devops-toolbox 1.9.20

package/tools/wip-repos/cli.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+/**
+ * wip-repos CLI ... repo manifest reconciler
+ *
+ * Commands:
+ *   check   - Diff filesystem against manifest, flag drift
+ *   sync    - Move local folders to match the manifest
+ *   add     - Add a repo to the manifest
+ *   move    - Move a repo to a different category in the manifest
+ *   tree    - Generate directory tree from manifest
+ */
+
+import { check, planSync, executeSync, addRepo, moveRepo, generateReadmeTree, loadManifest } from './core.mjs';
+import { resolve, dirname } from 'node:path';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function usage() {
+  console.log(`wip-repos ... repo manifest reconciler
+
+Usage:
+  wip-repos check [--manifest path] [--root path]
+  wip-repos sync  [--manifest path] [--root path] [--dry-run]
+  wip-repos add <path> --remote <org/repo> [--category cat] [--description desc]
+  wip-repos move <path> --to <new-path>
+  wip-repos tree  [--manifest path]
+
+Options:
+  --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
+  --json       Output as JSON`);
+}
+
+function getFlag(flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1) return undefined;
+  return args[idx + 1];
+}
+
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+
+const manifestPath = resolve(getFlag('--manifest') || 'repos-manifest.json');
+const reposRoot = resolve(getFlag('--root') || dirname(manifestPath));
+const dryRun = hasFlag('--dry-run');
+const jsonOutput = hasFlag('--json');
+
+try {
+  switch (command) {
+    case 'check': {
+      const result = check(manifestPath, reposRoot);
+
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      console.log(`Manifest: ${result.total.manifest} repos`);
+      console.log(`On disk:  ${result.total.disk} repos`);
+      console.log(`Matched:  ${result.total.matched}`);
+      console.log();
+
+      if (result.onDiskOnly.length > 0) {
+        console.log(`On disk but NOT in manifest (${result.onDiskOnly.length}):`);
+        for (const p of result.onDiskOnly) {
+          console.log(`  + ${p}`);
+        }
+        console.log();
+      }
+
+      if (result.inManifestOnly.length > 0) {
+        console.log(`In manifest but NOT on disk (${result.inManifestOnly.length}):`);
+        for (const p of result.inManifestOnly) {
+          console.log(`  - ${p}`);
+        }
+        console.log();
+      }
+
+      if (result.onDiskOnly.length === 0 && result.inManifestOnly.length === 0) {
+        console.log('No drift. Manifest and filesystem are in sync.');
+      }
+
+      // Exit code 1 if drift detected
+      if (result.onDiskOnly.length > 0 || result.inManifestOnly.length > 0) {
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'sync': {
+      const moves = planSync(manifestPath, reposRoot);
+
+      if (moves.length === 0) {
+        console.log('Nothing to sync. All repos are in the right place.');
+        break;
+      }
+
+      if (jsonOutput) {
+        console.log(JSON.stringify(moves, null, 2));
+        break;
+      }
+
+      console.log(`Found ${moves.length} repo(s) to move:\n`);
+      for (const m of moves) {
+        console.log(`  ${m.from} -> ${m.to}`);
+        console.log(`  (remote: ${m.remote})`);
+        console.log();
+      }
+
+      if (dryRun) {
+        console.log('Dry run. No changes made.');
+        break;
+      }
+
+      const results = executeSync(moves, reposRoot);
+      for (const r of results) {
+        if (r.status === 'moved') {
+          console.log(`  Moved: ${r.from} -> ${r.to}`);
+        } else if (r.status === 'skipped') {
+          console.log(`  Skipped: ${r.from} (${r.reason})`);
+        } else {
+          console.log(`  Error: ${r.from} (${r.reason})`);
+        }
+      }
+      break;
+    }
+
+    case 'add': {
+      const repoPath = args[1];
+      const remote = getFlag('--remote');
+      if (!repoPath || !remote) {
+        console.error('Usage: wip-repos add <path> --remote <org/repo>');
+        process.exit(1);
+      }
+      const entry = addRepo(manifestPath, repoPath, remote, {
+        category: getFlag('--category'),
+        description: getFlag('--description'),
+      });
+      console.log(`Added: ${repoPath} -> ${remote}`);
+      if (jsonOutput) console.log(JSON.stringify(entry, null, 2));
+      break;
+    }
+
+    case 'move': {
+      const fromPath = args[1];
+      const toPath = getFlag('--to');
+      if (!fromPath || !toPath) {
+        console.error('Usage: wip-repos move <path> --to <new-path>');
+        process.exit(1);
+      }
+      const entry = moveRepo(manifestPath, fromPath, toPath);
+      console.log(`Moved in manifest: ${fromPath} -> ${toPath}`);
+      if (jsonOutput) console.log(JSON.stringify(entry, null, 2));
+      break;
+    }
+
+    case 'tree': {
+      const tree = generateReadmeTree(manifestPath);
+      console.log(tree);
+      break;
+    }
+
+    default:
+      usage();
+      if (command && command !== '--help' && command !== '-h') {
+        process.exit(1);
+      }
+  }
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}

package/tools/wip-repos/core.mjs

@@ -0,0 +1,290 @@
+/**
+ * wip-repos core ... repo manifest reconciler
+ *
+ * The manifest is the source of truth. The filesystem adapts to it.
+ * Like prettier for folder structure.
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname, relative, resolve } from 'node:path';
+
+/**
+ * Load and parse a repos-manifest.json file.
+ * Supports both v1 (flat key-value) and v2 (rich objects) formats.
+ */
+export function loadManifest(manifestPath) {
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Manifest not found: ${manifestPath}`);
+  }
+  const raw = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+  // Detect format
+  const meta = {};
+  const repos = {};
+
+  for (const [key, value] of Object.entries(raw)) {
+    if (key.startsWith('_')) {
+      meta[key] = value;
+      continue;
+    }
+    if (typeof value === 'string') {
+      // v1 flat format: path -> remote
+      repos[key] = { remote: value };
+    } else if (typeof value === 'object' && value !== null) {
+      // v2 rich format
+      repos[key] = value;
+    }
+  }
+
+  return { meta, repos, format: meta._format || 'v1', path: manifestPath };
+}
+
+/**
+ * Save manifest back to disk.
+ */
+export function saveManifest(manifestPath, meta, repos) {
+  const out = {};
+  for (const [key, value] of Object.entries(meta)) {
+    out[key] = value;
+  }
+  for (const [key, value] of Object.entries(repos)) {
+    // v1: just write the remote string
+    if (Object.keys(value).length === 1 && value.remote) {
+      out[key] = value.remote;
+    } else {
+      out[key] = value;
+    }
+  }
+  writeFileSync(manifestPath, JSON.stringify(out, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Walk a directory tree and find all git repos (directories containing .git/).
+ * Returns array of relative paths from the root.
+ */
+export function walkRepos(rootDir, prefix = '') {
+  const results = [];
+  if (!existsSync(rootDir)) return results;
+
+  const entries = readdirSync(rootDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === '.git' || entry.name === 'node_modules') continue;
+    if (entry.name === '.DS_Store') continue;
+
+    const fullPath = join(rootDir, entry.name);
+    const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+    // If this directory has a .git, it's a repo
+    if (existsSync(join(fullPath, '.git'))) {
+      results.push(relPath);
+    } else {
+      // Recurse into non-repo directories (organizational folders)
+      results.push(...walkRepos(fullPath, relPath));
+    }
+  }
+  return results;
+}
+
+/**
+ * Check: diff the filesystem against the manifest.
+ * Returns { inManifestOnly, onDiskOnly, matched }
+ */
+export function check(manifestPath, reposRoot) {
+  const manifest = loadManifest(manifestPath);
+  const manifestPaths = new Set(Object.keys(manifest.repos));
+  const diskPaths = new Set(walkRepos(reposRoot));
+
+  const inManifestOnly = [];
+  const onDiskOnly = [];
+  const matched = [];
+
+  for (const p of manifestPaths) {
+    if (diskPaths.has(p)) {
+      matched.push(p);
+    } else {
+      inManifestOnly.push(p);
+    }
+  }
+
+  for (const p of diskPaths) {
+    if (!manifestPaths.has(p)) {
+      onDiskOnly.push(p);
+    }
+  }
+
+  return {
+    inManifestOnly: inManifestOnly.sort(),
+    onDiskOnly: onDiskOnly.sort(),
+    matched: matched.sort(),
+    total: {
+      manifest: manifestPaths.size,
+      disk: diskPaths.size,
+      matched: matched.length,
+    },
+  };
+}
+
+/**
+ * Sync: move local folders to match the manifest.
+ * Returns array of { from, to } moves that were performed.
+ *
+ * Only handles repos that exist on disk but at the wrong path.
+ * Matches by remote URL (git remote -v) against manifest remotes.
+ */
+export function planSync(manifestPath, reposRoot) {
+  const manifest = loadManifest(manifestPath);
+  const diskPaths = walkRepos(reposRoot);
+  const moves = [];
+
+  // Build a map of remote -> manifest path
+  const remoteToManifest = new Map();
+  for (const [mPath, info] of Object.entries(manifest.repos)) {
+    if (info.remote) {
+      remoteToManifest.set(info.remote, mPath);
+    }
+  }
+
+  // For each repo on disk, check if its remote matches a manifest entry at a different path
+  for (const diskPath of diskPaths) {
+    const fullPath = join(reposRoot, diskPath);
+    const gitConfig = join(fullPath, '.git', 'config');
+    if (!existsSync(gitConfig)) continue;
+
+    const configText = readFileSync(gitConfig, 'utf8');
+    // Extract remote URL
+    const match = configText.match(/url\s*=\s*.*[:/]([^/]+\/[^/\s.]+?)(?:\.git)?\s*$/m);
+    if (!match) continue;
+
+    const remote = match[1];
+    const expectedPath = remoteToManifest.get(remote);
+
+    if (expectedPath && expectedPath !== diskPath) {
+      moves.push({
+        from: diskPath,
+        to: expectedPath,
+        remote,
+        fromFull: fullPath,
+        toFull: join(reposRoot, expectedPath),
+      });
+    }
+  }
+
+  return moves;
+}
+
+/**
+ * Execute sync moves. Creates parent directories as needed.
+ */
+export function executeSync(moves, reposRoot) {
+  const results = [];
+  for (const move of moves) {
+    const parentDir = dirname(move.toFull);
+    if (!existsSync(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+    if (existsSync(move.toFull)) {
+      results.push({ ...move, status: 'skipped', reason: 'target exists' });
+      continue;
+    }
+    try {
+      renameSync(move.fromFull, move.toFull);
+      results.push({ ...move, status: 'moved' });
+    } catch (err) {
+      results.push({ ...move, status: 'error', reason: err.message });
+    }
+  }
+  return results;
+}
+
+/**
+ * Add a repo to the manifest.
+ */
+export function addRepo(manifestPath, repoPath, remote, opts = {}) {
+  const manifest = loadManifest(manifestPath);
+
+  if (manifest.repos[repoPath]) {
+    throw new Error(`Already in manifest: ${repoPath}`);
+  }
+
+  const entry = { remote };
+  if (opts.description) entry.description = opts.description;
+  if (opts.category) entry.category = opts.category;
+  if (opts.public) entry.public = opts.public;
+  if (opts.privatized !== undefined) entry.privatized = opts.privatized;
+
+  manifest.repos[repoPath] = entry;
+  saveManifest(manifestPath, manifest.meta, manifest.repos);
+
+  return entry;
+}
+
+/**
+ * Move a repo in the manifest from one path to another.
+ */
+export function moveRepo(manifestPath, fromPath, toPath) {
+  const manifest = loadManifest(manifestPath);
+
+  if (!manifest.repos[fromPath]) {
+    throw new Error(`Not in manifest: ${fromPath}`);
+  }
+  if (manifest.repos[toPath]) {
+    throw new Error(`Target already exists in manifest: ${toPath}`);
+  }
+
+  manifest.repos[toPath] = manifest.repos[fromPath];
+  delete manifest.repos[fromPath];
+  saveManifest(manifestPath, manifest.meta, manifest.repos);
+
+  return manifest.repos[toPath];
+}
+
+/**
+ * Generate a markdown directory tree from the manifest.
+ */
+export function generateReadmeTree(manifestPath) {
+  const manifest = loadManifest(manifestPath);
+  const paths = Object.keys(manifest.repos).sort();
+
+  // Build tree structure
+  const tree = {};
+  for (const p of paths) {
+    const parts = p.split('/');
+    let node = tree;
+    for (const part of parts) {
+      if (!node[part]) node[part] = {};
+      node = node[part];
+    }
+  }
+
+  // Render tree
+  const lines = ['repos/'];
+  function render(node, prefix, isLast) {
+    const entries = Object.keys(node).sort((a, b) => {
+      // underscore-prefixed folders sort to top
+      const aUnder = a.startsWith('_');
+      const bUnder = b.startsWith('_');
+      if (aUnder && !bUnder) return 1;
+      if (!aUnder && bUnder) return -1;
+      return a.localeCompare(b);
+    });
+
+    for (let i = 0; i < entries.length; i++) {
+      const name = entries[i];
+      const last = i === entries.length - 1;
+      const connector = last ? '└── ' : '├── ';
+      const childPrefix = last ? '    ' : '│   ';
+      const children = Object.keys(node[name]);
+
+      if (children.length > 0) {
+        lines.push(`${prefix}${connector}${name}/`);
+        render(node[name], prefix + childPrefix, last);
+      } else {
+        lines.push(`${prefix}${connector}${name}`);
+      }
+    }
+  }
+
+  render(tree, '', false);
+  return lines.join('\n');
+}

package/tools/wip-repos/mcp-server.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// wip-repos/mcp-server.mjs
+// MCP server exposing repo manifest reconciler as tools.
+// Wraps core.mjs. Registered via .mcp.json.
+
+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,
+} from './core.mjs';
+
+const server = new Server(
+  { name: 'wip-repos', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+);
+
+// ── Tool Definitions ──
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'repos_check',
+      description: 'Diff the filesystem against the manifest. Shows repos in manifest but not on disk, on disk but not in manifest, and matched.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+          reposRoot: { type: 'string', description: 'Root directory containing repos' },
+        },
+        required: ['manifestPath', 'reposRoot'],
+      },
+    },
+    {
+      name: 'repos_sync_plan',
+      description: 'Plan moves to reconcile filesystem with manifest. Matches repos by git remote URL. Returns planned moves without executing.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+          reposRoot: { type: 'string', description: 'Root directory containing repos' },
+        },
+        required: ['manifestPath', 'reposRoot'],
+      },
+    },
+    {
+      name: 'repos_add',
+      description: 'Add a repo to the manifest.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+          repoPath: { type: 'string', description: 'Relative path in the manifest (e.g. ldm-os/utilities/my-tool)' },
+          remote: { type: 'string', description: 'GitHub remote (e.g. wipcomputer/my-tool)' },
+          description: { type: 'string', description: 'Short description' },
+        },
+        required: ['manifestPath', 'repoPath', 'remote'],
+      },
+    },
+    {
+      name: 'repos_move',
+      description: 'Move a repo in the manifest from one path to another.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+          fromPath: { type: 'string', description: 'Current manifest path' },
+          toPath: { type: 'string', description: 'New manifest path' },
+        },
+        required: ['manifestPath', 'fromPath', 'toPath'],
+      },
+    },
+    {
+      name: 'repos_tree',
+      description: 'Generate a markdown directory tree from the manifest.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          manifestPath: { type: 'string', description: 'Path to repos-manifest.json' },
+        },
+        required: ['manifestPath'],
+      },
+    },
+  ],
+}));
+
+// ── Tool Handlers ──
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args } = req.params;
+
+  try {
+    if (name === 'repos_check') {
+      const result = check(args.manifestPath, args.reposRoot);
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify(result, null, 2),
+        }],
+      };
+    }
+
+    if (name === 'repos_sync_plan') {
+      const moves = planSync(args.manifestPath, args.reposRoot);
+      return {
+        content: [{
+          type: 'text',
+          text: moves.length === 0
+            ? 'No moves needed. Filesystem matches manifest.'
+            : JSON.stringify(moves.map(m => ({ from: m.from, to: m.to, remote: m.remote })), null, 2),
+        }],
+      };
+    }
+
+    if (name === 'repos_add') {
+      const entry = addRepo(args.manifestPath, args.repoPath, args.remote, {
+        description: args.description,
+      });
+      return {
+        content: [{
+          type: 'text',
+          text: `Added ${args.repoPath} -> ${args.remote}`,
+        }],
+      };
+    }
+
+    if (name === 'repos_move') {
+      moveRepo(args.manifestPath, args.fromPath, args.toPath);
+      return {
+        content: [{
+          type: 'text',
+          text: `Moved ${args.fromPath} -> ${args.toPath}`,
+        }],
+      };
+    }
+
+    if (name === 'repos_tree') {
+      const tree = generateReadmeTree(args.manifestPath);
+      return {
+        content: [{ type: 'text', text: tree }],
+      };
+    }
+
+    return {
+      content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+      isError: true,
+    };
+  } catch (err) {
+    return {
+      content: [{ type: 'text', text: `Error: ${err.message}` }],
+      isError: true,
+    };
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/tools/wip-repos/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@wipcomputer/wip-repos",
+  "version": "1.9.20",
+  "type": "module",
+  "description": "Repo manifest reconciler. Single source of truth for repo organization. Like prettier for folder structure.",
+  "main": "core.mjs",
+  "bin": {
+    "wip-repos": "./cli.mjs"
+  },
+  "exports": {
+    ".": "./core.mjs"
+  },
+  "scripts": {
+    "test": "node cli.mjs --help"
+  },
+  "keywords": [
+    "repo-manifest",
+    "monorepo",
+    "toolbox",
+    "organization",
+    "enterprise",
+    "ai-dev-tools"
+  ],
+  "author": "Parker Todd Brooks",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wipcomputer/wip-ai-devops-toolbox.git",
+    "directory": "tools/wip-repos"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}