@wipcomputer/wip-repos 0.1.0

package/LICENSE

@@ -0,0 +1,52 @@
+Dual License: MIT + AGPLv3
+
+Copyright (c) 2026 WIP Computer, Inc.
+
+
+1. MIT License (local and personal use)
+---------------------------------------
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+2. GNU Affero General Public License v3.0 (commercial and cloud use)
+--------------------------------------------------------------------
+
+If you run this software as part of a hosted service, cloud platform,
+marketplace listing, or any network-accessible offering for commercial
+purposes, the AGPLv3 terms apply. You must either:
+
+  a) Release your complete source code under AGPLv3, or
+  b) Obtain a commercial license.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+AGPLv3 for personal use is free. Commercial licenses available.

package/README.md

@@ -0,0 +1,77 @@
+###### WIP Computer
+
+[![npm](https://img.shields.io/npm/v/@wipcomputer/wip-repos)](https://www.npmjs.com/package/@wipcomputer/wip-repos) [![CLI / TUI](https://img.shields.io/badge/interface-CLI_/_TUI-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-repos/cli.mjs) [![MCP Server](https://img.shields.io/badge/interface-MCP_Server-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-repos/mcp-server.mjs) [![Claude Code Skill](https://img.shields.io/badge/interface-Claude_Code_Skill-black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-repos/SKILL.md) [![Universal Interface Spec](https://img.shields.io/badge/Universal_Interface_Spec-black?style=flat&color=black)](https://github.com/wipcomputer/wip-ai-devops-toolbox/blob/main/tools/wip-universal-installer/SPEC.md)
+
+# wip-repos
+
+Repo manifest reconciler. Single source of truth for repo organization.
+
+## The Problem
+
+You have 50 repos. Someone moves a folder. The README drifts. The manifest drifts. Your AI agent references a path that doesn't exist anymore. Everyone wastes time.
+
+## The Solution
+
+`repos-manifest.json` is the single source of truth. The filesystem adapts to it. Like prettier for folder structure.
+
+Move folders around all day. On sync, everything snaps back to where the manifest says it belongs. Want to change the structure? PR to the manifest. Org owner approves or rejects. Rejected? Your folders snap back on next sync.
+
+## Usage
+
+```bash
+# Check for drift between filesystem and manifest
+wip-repos check
+
+# See what sync would do
+wip-repos sync --dry-run
+
+# Actually move folders to match manifest
+wip-repos sync
+
+# Add a new repo
+wip-repos add ldm-os/utilities/my-tool --remote wipcomputer/my-tool
+
+# Move a repo to a different category
+wip-repos move ldm-os/utilities/my-tool --to ldm-os/devops/my-tool
+
+# Generate directory tree from manifest
+wip-repos tree
+```
+
+## 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
+```
+
+## How It Works
+
+1. **check** walks the filesystem, finds all git repos, compares against the manifest. Reports what's on disk but not in manifest, and what's in manifest but not on disk. Exit code 1 if drift detected.
+
+2. **sync** matches repos by their git remote URL. If a repo's remote matches a manifest entry but it's at the wrong path, sync moves it to the manifest path.
+
+3. **add/move** update the manifest file. The actual folder moves happen on the next `sync`.
+
+## 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.
+- README generation: `wip-repos tree` outputs a directory tree from the manifest.
+
+## Source
+
+Pure JavaScript. Zero dependencies. `core.mjs` (logic), `cli.mjs` (CLI). No build step.
+
+## License
+
+```
+CLI, MCP server, module                        MIT    (use anywhere, no restrictions)
+Hosted or cloud service use                    AGPL   (network service distribution)
+```
+
+AGPL for personal use is free.
+
+Built by Parker Todd Brooks, Lēsa (OpenClaw, Claude Opus 4.6), Claude Code (Claude Opus 4.6).

package/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: wip-repos
+description: Repo manifest reconciler. Makes repos-manifest.json the single source of truth for repo organization.
+license: MIT
+interface: [cli, module, mcp]
+metadata:
+  display-name: "Repo Manifest Reconciler"
+  version: "0.1.0"
+  homepage: "https://github.com/wipcomputer/wip-ai-devops-toolbox"
+  author: "Parker Todd Brooks"
+  category: dev-tools
+  capabilities:
+    - manifest-check
+    - filesystem-sync
+    - repo-add
+    - repo-move
+    - tree-generation
+  requires:
+    bins: [node, git]
+  openclaw:
+    requires:
+      bins: [node, git]
+    install:
+      - id: node
+        kind: node
+        package: "@wipcomputer/wip-repos"
+        bins: [wip-repos]
+        label: "Install via npm"
+    emoji: "📂"
+compatibility: Requires git, node. Node.js 18+.
+---
+
+# wip-repos
+
+Repo manifest reconciler. Like prettier for folder structure. Move folders around all day; on sync, everything snaps back to where the manifest says.
+
+## When to Use This Skill
+
+**Use wip-repos for:**
+- Checking if the filesystem matches the manifest (`check`)
+- Moving repos to match the manifest (`sync`)
+- Adding a new repo to the manifest (`add`)
+- Moving a repo in the manifest (`move`)
+- Generating a directory tree from the manifest (`tree`)
+
+**Use after:**
+- Cloning a new repo
+- Moving repos between categories
+- Adding new repos to the org
+
+### Do NOT Use For
+
+- Git operations (use git directly)
+- Repo creation on GitHub (use gh)
+
+## API Reference
+
+### CLI
+
+```bash
+wip-repos check                              # diff filesystem vs manifest
+wip-repos sync --dry-run                     # preview moves
+wip-repos sync                               # execute moves
+wip-repos add ldm-os/utilities/new-tool --remote wipcomputer/new-tool
+wip-repos move ldm-os/utilities/tool --to ldm-os/devops/tool
+wip-repos tree                               # generate directory tree
+```
+
+### Module
+
+```javascript
+import { check, planSync, addRepo, moveRepo, generateReadmeTree } from '@wipcomputer/wip-repos';
+
+const result = check('/path/to/manifest.json', '/path/to/repos/');
+const moves = planSync('/path/to/manifest.json', '/path/to/repos/');
+```
+
+### MCP
+
+Tools: `repos_check`, `repos_sync_plan`, `repos_add`, `repos_move`, `repos_tree`

package/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/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/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/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@wipcomputer/wip-repos",
+  "version": "0.1.0",
+  "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"
+  }
+}