@nemus-cli/nemus 0.2.1

package/dist/utils/dashboard-hooks.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installDashboardHooks = installDashboardHooks;
+exports.areDashboardHooksInstalled = areDashboardHooksInstalled;
+exports.uninstallDashboardHooks = uninstallDashboardHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const dashboard_1 = require("../types/dashboard");
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+/** Events we register hooks for */
+const HOOK_EVENTS = ['SessionStart', 'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Notification', 'Stop', 'SessionEnd'];
+/**
+ * Resolve path to the compiled hook-handler.js.
+ * This file (dashboard-hooks.ts) compiles to dist/utils/dashboard-hooks.js,
+ * so hook-handler.js is at ../commands/dashboard/hook-handler.js relative to dist/utils/.
+ */
+function getHookHandlerPath() {
+    return path.join(__dirname, '..', 'commands', 'dashboard', 'hook-handler.js');
+}
+/**
+ * Build the hook command string for a given event.
+ */
+function buildHookCommand(event) {
+    const handlerPath = getHookHandlerPath();
+    return `node "${handlerPath}" --event ${event} --marker ${dashboard_1.HOOK_MARKER}`;
+}
+/**
+ * Read Claude settings from disk. Returns empty settings if file doesn't exist.
+ */
+function readClaudeSettings() {
+    try {
+        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Write Claude settings to disk atomically (write to .tmp, then rename).
+ * Prevents corruption if the process is interrupted mid-write.
+ */
+function writeClaudeSettings(settings) {
+    const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = CLAUDE_SETTINGS_PATH + '.tmp';
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+        fs.renameSync(tmp, CLAUDE_SETTINGS_PATH);
+    }
+    catch (err) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * Check if a hook group contains our dashboard hook marker.
+ */
+function groupContainsMarker(group) {
+    return group.hooks.some(h => h.command && h.command.includes(dashboard_1.HOOK_MARKER));
+}
+/**
+ * Install dashboard hooks into Claude settings.
+ * Appends new hook groups — never modifies existing hooks.
+ * Idempotent: skips events that already have the marker.
+ */
+function installDashboardHooks() {
+    const settings = readClaudeSettings();
+    if (!settings.hooks) {
+        settings.hooks = {};
+    }
+    for (const event of HOOK_EVENTS) {
+        if (!settings.hooks[event]) {
+            settings.hooks[event] = [];
+        }
+        // Check if already installed
+        const alreadyInstalled = settings.hooks[event].some(groupContainsMarker);
+        if (alreadyInstalled) {
+            continue;
+        }
+        // Append a new hook group
+        const hookGroup = {
+            hooks: [
+                {
+                    type: 'command',
+                    command: buildHookCommand(event),
+                    timeout: 5,
+                },
+            ],
+        };
+        // PreToolUse and PostToolUse hooks use a matcher — use empty string to match all tools
+        if (event === 'PreToolUse' || event === 'PostToolUse') {
+            hookGroup.matcher = '';
+        }
+        settings.hooks[event].push(hookGroup);
+    }
+    writeClaudeSettings(settings);
+}
+/**
+ * Check if all dashboard hooks are installed.
+ */
+function areDashboardHooksInstalled() {
+    const settings = readClaudeSettings();
+    if (!settings.hooks)
+        return false;
+    return HOOK_EVENTS.every(event => {
+        const groups = settings.hooks?.[event];
+        if (!groups || !Array.isArray(groups))
+            return false;
+        return groups.some(groupContainsMarker);
+    });
+}
+/**
+ * Remove all dashboard hooks from Claude settings.
+ * Only removes hook groups containing the HOOK_MARKER — leaves everything else untouched.
+ */
+function uninstallDashboardHooks() {
+    const settings = readClaudeSettings();
+    if (!settings.hooks)
+        return;
+    for (const event of HOOK_EVENTS) {
+        if (!settings.hooks[event])
+            continue;
+        settings.hooks[event] = settings.hooks[event].filter(g => !groupContainsMarker(g));
+        // Clean up empty arrays
+        if (settings.hooks[event].length === 0) {
+            delete settings.hooks[event];
+        }
+    }
+    // Clean up empty hooks object
+    if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+    writeClaudeSettings(settings);
+}

package/dist/utils/dependency-analyzer.js

@@ -0,0 +1,234 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWorkspaceMetadata = exports.generateMermaidDiagram = exports.detectCircularDependencies = exports.analyzeDependencies = exports.analyzeDockerCompose = exports.analyzeDockerfile = exports.analyzeImports = exports.analyzePackageJson = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const analyzePackageJson = async (repoPath) => {
+    try {
+        const packageJsonPath = path.join(repoPath, 'package.json');
+        const content = await fs.readFile(packageJsonPath, 'utf-8');
+        const packageJson = JSON.parse(content);
+        const dependencies = [];
+        // Check dependencies and devDependencies
+        const allDeps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        const { githubOrg } = (0, config_1.getUserConfig)();
+        const scopePrefix = githubOrg ? `@${githubOrg}/` : '';
+        for (const dep of Object.keys(allDeps)) {
+            // Match packages under the configured org scope (e.g. @your-org/*), or any
+            // scoped package as a fallback so cross-repo links are still detected.
+            if (dep.startsWith('@')) {
+                dependencies.push(scopePrefix && dep.startsWith(scopePrefix)
+                    ? dep.slice(scopePrefix.length)
+                    : dep.replace(/^@[^/]+\//, '').replace('@', ''));
+            }
+        }
+        return dependencies;
+    }
+    catch {
+        return [];
+    }
+};
+exports.analyzePackageJson = analyzePackageJson;
+const analyzeImports = async (repoPath) => {
+    try {
+        const dependencies = new Set();
+        // Scan source files for relative imports that might indicate dependencies
+        const scanDirs = ['src', 'lib', 'app'];
+        for (const dir of scanDirs) {
+            const dirPath = path.join(repoPath, dir);
+            try {
+                await fs.access(dirPath);
+                // For simplicity, we're not doing deep file scanning here
+                // In a real implementation, you'd recursively read .ts, .js, .tsx files
+            }
+            catch {
+                continue;
+            }
+        }
+        return Array.from(dependencies);
+    }
+    catch {
+        return [];
+    }
+};
+exports.analyzeImports = analyzeImports;
+const analyzeDockerfile = async (repoPath) => {
+    try {
+        const dockerfilePath = path.join(repoPath, 'Dockerfile');
+        const content = await fs.readFile(dockerfilePath, 'utf-8');
+        const dependencies = [];
+        const fromRegex = /FROM\s+([^\s]+)/g;
+        let match;
+        while ((match = fromRegex.exec(content)) !== null) {
+            const image = match[1];
+            // Extract potential dependency references to other org images. When an org
+            // is configured, treat images named after it (e.g. `your-org-foo`) as deps.
+            const { githubOrg } = (0, config_1.getUserConfig)();
+            if (githubOrg && image.includes(githubOrg)) {
+                dependencies.push(image.split(':')[0].replace(`${githubOrg}-`, ''));
+            }
+        }
+        return dependencies;
+    }
+    catch {
+        return [];
+    }
+};
+exports.analyzeDockerfile = analyzeDockerfile;
+const analyzeDockerCompose = async (repoPath) => {
+    try {
+        const composePath = path.join(repoPath, 'docker-compose.yml');
+        const content = await fs.readFile(composePath, 'utf-8');
+        const dependencies = [];
+        // Simple pattern matching for service references
+        const serviceRegex = /depends_on:\s*\n((?:\s+-\s+\w+\n)+)/g;
+        let match;
+        while ((match = serviceRegex.exec(content)) !== null) {
+            const services = match[1].match(/\w+/g);
+            if (services) {
+                dependencies.push(...services);
+            }
+        }
+        return dependencies;
+    }
+    catch {
+        return [];
+    }
+};
+exports.analyzeDockerCompose = analyzeDockerCompose;
+const analyzeDependencies = async (workspacePath, repoNames) => {
+    const analyses = new Map();
+    for (const repoName of repoNames) {
+        const repoPath = path.join(workspacePath, repoName);
+        const [packageDeps, dockerDeps, composeDeps] = await Promise.all([
+            (0, exports.analyzePackageJson)(repoPath),
+            (0, exports.analyzeDockerfile)(repoPath),
+            (0, exports.analyzeDockerCompose)(repoPath),
+        ]);
+        const allDeps = [...new Set([...packageDeps, ...dockerDeps, ...composeDeps])];
+        // Filter to only dependencies that are in the workspace
+        const validDeps = allDeps.filter(dep => repoNames.includes(dep));
+        // Find missing dependencies (referenced but not in workspace)
+        const missingDeps = allDeps.filter(dep => !repoNames.includes(dep));
+        analyses.set(repoName, {
+            repoName,
+            dependencies: validDeps,
+            dependents: [], // Will be filled in next pass
+            missingDependencies: missingDeps,
+        });
+    }
+    // Build dependents lists
+    for (const [repoName, analysis] of analyses) {
+        for (const dep of analysis.dependencies) {
+            const depAnalysis = analyses.get(dep);
+            if (depAnalysis && !depAnalysis.dependents.includes(repoName)) {
+                depAnalysis.dependents.push(repoName);
+            }
+        }
+    }
+    return analyses;
+};
+exports.analyzeDependencies = analyzeDependencies;
+const detectCircularDependencies = (analyses) => {
+    const visited = new Set();
+    const recursionStack = new Set();
+    const cycles = [];
+    const dfs = (repo, path) => {
+        visited.add(repo);
+        recursionStack.add(repo);
+        path.push(repo);
+        const analysis = analyses.get(repo);
+        if (analysis) {
+            for (const dep of analysis.dependencies) {
+                if (!visited.has(dep)) {
+                    dfs(dep, [...path]);
+                }
+                else if (recursionStack.has(dep)) {
+                    // Found a cycle
+                    const cycleStart = path.indexOf(dep);
+                    const cycle = path.slice(cycleStart);
+                    cycle.push(dep);
+                    cycles.push(cycle);
+                }
+            }
+        }
+        recursionStack.delete(repo);
+    };
+    for (const repoName of analyses.keys()) {
+        if (!visited.has(repoName)) {
+            dfs(repoName, []);
+        }
+    }
+    return cycles;
+};
+exports.detectCircularDependencies = detectCircularDependencies;
+const generateMermaidDiagram = (analyses) => {
+    const lines = ['```mermaid', 'graph TD'];
+    for (const [repoName, analysis] of analyses) {
+        const nodeId = repoName.replace(/[^a-zA-Z0-9]/g, '_');
+        for (const dep of analysis.dependencies) {
+            const depId = dep.replace(/[^a-zA-Z0-9]/g, '_');
+            lines.push(`  ${nodeId}[${repoName}] --> ${depId}[${dep}]`);
+        }
+        // Add standalone nodes (no dependencies)
+        if (analysis.dependencies.length === 0 && analysis.dependents.length === 0) {
+            lines.push(`  ${nodeId}[${repoName}]`);
+        }
+    }
+    lines.push('```');
+    return lines.join('\n');
+};
+exports.generateMermaidDiagram = generateMermaidDiagram;
+const updateWorkspaceMetadata = (metadata, analyses) => {
+    const dependencies = {};
+    for (const [repoName, analysis] of analyses) {
+        dependencies[repoName] = {
+            dependsOn: analysis.dependencies,
+            dependedBy: analysis.dependents,
+            lastAnalyzed: new Date().toISOString(),
+        };
+    }
+    return {
+        ...metadata,
+        dependencies,
+        lastModified: new Date().toISOString(),
+    };
+};
+exports.updateWorkspaceMetadata = updateWorkspaceMetadata;

package/dist/utils/diff-operations.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiffStat = parseDiffStat;
+exports.getRepoDiff = getRepoDiff;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const fs = __importStar(require("fs/promises"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function parseDiffStat(output) {
+    const match = output.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+    if (!match) {
+        return { files: 0, insertions: 0, deletions: 0 };
+    }
+    return {
+        files: parseInt(match[1], 10) || 0,
+        insertions: parseInt(match[2], 10) || 0,
+        deletions: parseInt(match[3], 10) || 0,
+    };
+}
+async function getRepoDiff(repoPath, repoName) {
+    try {
+        await fs.access(repoPath);
+    }
+    catch {
+        return { repo: repoName, staged: { files: 0, insertions: 0, deletions: 0 }, unstaged: { files: 0, insertions: 0, deletions: 0 }, error: 'Directory not found' };
+    }
+    try {
+        const [unstagedResult, stagedResult] = await Promise.all([
+            execAsync('git diff --stat', { cwd: repoPath }).catch(() => ({ stdout: '' })),
+            execAsync('git diff --cached --stat', { cwd: repoPath }).catch(() => ({ stdout: '' })),
+        ]);
+        return {
+            repo: repoName,
+            unstaged: parseDiffStat(unstagedResult.stdout),
+            staged: parseDiffStat(stagedResult.stdout),
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            repo: repoName,
+            staged: { files: 0, insertions: 0, deletions: 0 },
+            unstaged: { files: 0, insertions: 0, deletions: 0 },
+            error: errorMessage,
+        };
+    }
+}

package/dist/utils/doc-generator.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDocs = exports.generateRepositoryIndex = exports.generateDependencyGraph = exports.generateWorkspaceReadme = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const dependency_analyzer_1 = require("./dependency-analyzer");
+const generateWorkspaceReadme = async (metadata, workspacePath) => {
+    const lines = [];
+    lines.push(`# ${metadata.workspaceName}`);
+    lines.push('');
+    if (metadata.description) {
+        lines.push(metadata.description);
+        lines.push('');
+    }
+    lines.push('## Overview');
+    lines.push('');
+    lines.push(`- **Created:** ${new Date(metadata.createdAt).toLocaleString()}`);
+    if (metadata.lastModified) {
+        lines.push(`- **Last Modified:** ${new Date(metadata.lastModified).toLocaleString()}`);
+    }
+    lines.push(`- **Repositories:** ${metadata.repositories.length}`);
+    lines.push('');
+    lines.push('## Repositories');
+    lines.push('');
+    const tableData = [
+        ['Repository', 'Owner', 'Cloned At', 'Status'],
+    ];
+    for (const repo of metadata.repositories) {
+        tableData.push([
+            repo.name,
+            repo.owner,
+            new Date(repo.clonedAt).toLocaleDateString(),
+            repo.status === 'success' ? '✓' : '✗',
+        ]);
+    }
+    // Simple table generation without markdown-table for now
+    for (const row of tableData) {
+        lines.push('| ' + row.join(' | ') + ' |');
+        if (tableData.indexOf(row) === 0) {
+            lines.push('| ' + row.map(() => '---').join(' | ') + ' |');
+        }
+    }
+    lines.push('');
+    lines.push('## Quick Start');
+    lines.push('');
+    lines.push('```bash');
+    lines.push(`# Navigate to workspace`);
+    lines.push(`wgo ${metadata.workspaceName}`);
+    lines.push('');
+    lines.push('# Check status');
+    lines.push(`workspace status ${metadata.workspaceName}`);
+    lines.push('');
+    lines.push('# Sync all repositories');
+    lines.push(`workspace sync ${metadata.workspaceName}`);
+    lines.push('```');
+    lines.push('');
+    lines.push('## Commands');
+    lines.push('');
+    lines.push('- `workspace status` - Check git status across all repos');
+    lines.push('- `workspace doctor` - Run health checks');
+    lines.push('- `workspace sync` - Pull latest changes');
+    lines.push('- `workspace switch-branch` - Switch all repos to a branch');
+    lines.push('- `workspace analyze-deps` - Analyze dependencies');
+    lines.push('');
+    return lines.join('\n');
+};
+exports.generateWorkspaceReadme = generateWorkspaceReadme;
+const generateDependencyGraph = (metadata) => {
+    const lines = [];
+    lines.push('# Dependency Graph');
+    lines.push('');
+    if (metadata.dependencies) {
+        const analyses = new Map();
+        for (const [repoName, depInfo] of Object.entries(metadata.dependencies)) {
+            analyses.set(repoName, {
+                repoName,
+                dependencies: depInfo.dependsOn,
+                dependents: depInfo.dependedBy,
+                missingDependencies: [],
+            });
+        }
+        const diagram = (0, dependency_analyzer_1.generateMermaidDiagram)(analyses);
+        lines.push(diagram);
+    }
+    else {
+        lines.push('No dependency analysis available. Run `workspace analyze-deps` to generate.');
+    }
+    lines.push('');
+    lines.push('## Dependency Details');
+    lines.push('');
+    if (metadata.dependencies) {
+        for (const [repoName, depInfo] of Object.entries(metadata.dependencies)) {
+            lines.push(`### ${repoName}`);
+            lines.push('');
+            if (depInfo.dependsOn.length > 0) {
+                lines.push(`**Depends on:** ${depInfo.dependsOn.join(', ')}`);
+                lines.push('');
+            }
+            if (depInfo.dependedBy.length > 0) {
+                lines.push(`**Depended by:** ${depInfo.dependedBy.join(', ')}`);
+                lines.push('');
+            }
+            if (depInfo.dependsOn.length === 0 && depInfo.dependedBy.length === 0) {
+                lines.push('No dependencies');
+                lines.push('');
+            }
+        }
+    }
+    return lines.join('\n');
+};
+exports.generateDependencyGraph = generateDependencyGraph;
+const generateRepositoryIndex = async (metadata, workspacePath) => {
+    const lines = [];
+    lines.push('# Repository Index');
+    lines.push('');
+    for (const repo of metadata.repositories) {
+        const repoPath = path.join(workspacePath, repo.name);
+        lines.push(`## ${repo.name}`);
+        lines.push('');
+        lines.push(`- **Owner:** ${repo.owner}`);
+        lines.push(`- **Clone URL:** ${repo.cloneUrl}`);
+        lines.push(`- **Cloned At:** ${new Date(repo.clonedAt).toLocaleString()}`);
+        // Try to read package.json for tech stack info
+        try {
+            const packageJsonPath = path.join(repoPath, 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            if (packageJson.description) {
+                lines.push(`- **Description:** ${packageJson.description}`);
+            }
+            if (packageJson.scripts) {
+                const scripts = Object.keys(packageJson.scripts).slice(0, 5);
+                lines.push(`- **Scripts:** ${scripts.join(', ')}`);
+            }
+        }
+        catch {
+            // No package.json or can't read
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+};
+exports.generateRepositoryIndex = generateRepositoryIndex;
+const writeDocs = async (workspacePath, metadata) => {
+    const readme = await (0, exports.generateWorkspaceReadme)(metadata, workspacePath);
+    await fs.writeFile(path.join(workspacePath, 'WORKSPACE-README.md'), readme, 'utf-8');
+    const depGraph = (0, exports.generateDependencyGraph)(metadata);
+    await fs.writeFile(path.join(workspacePath, 'DEPENDENCY-GRAPH.md'), depGraph, 'utf-8');
+    const repoIndex = await (0, exports.generateRepositoryIndex)(metadata, workspacePath);
+    await fs.writeFile(path.join(workspacePath, 'REPOSITORY-INDEX.md'), repoIndex, 'utf-8');
+};
+exports.writeDocs = writeDocs;