@nemus-cli/nemus 0.2.1

package/src/utils/dashboard-hooks.ts

@@ -0,0 +1,163 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { HOOK_MARKER } from '../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'] as const;
+
+interface HookEntry {
+  type: string;
+  command: string;
+  timeout?: number;
+}
+
+interface HookGroup {
+  matcher?: string;
+  hooks: HookEntry[];
+}
+
+interface ClaudeSettings {
+  hooks?: Record<string, HookGroup[]>;
+  [key: string]: any;
+}
+
+/**
+ * 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(): string {
+  return path.join(__dirname, '..', 'commands', 'dashboard', 'hook-handler.js');
+}
+
+/**
+ * Build the hook command string for a given event.
+ */
+function buildHookCommand(event: string): string {
+  const handlerPath = getHookHandlerPath();
+  return `node "${handlerPath}" --event ${event} --marker ${HOOK_MARKER}`;
+}
+
+/**
+ * Read Claude settings from disk. Returns empty settings if file doesn't exist.
+ */
+function readClaudeSettings(): ClaudeSettings {
+  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: ClaudeSettings): void {
+  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: HookGroup): boolean {
+  return group.hooks.some(h => h.command && h.command.includes(HOOK_MARKER));
+}
+
+/**
+ * Install dashboard hooks into Claude settings.
+ * Appends new hook groups — never modifies existing hooks.
+ * Idempotent: skips events that already have the marker.
+ */
+export function installDashboardHooks(): void {
+  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: 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.
+ */
+export function areDashboardHooksInstalled(): boolean {
+  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.
+ */
+export function uninstallDashboardHooks(): void {
+  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/src/utils/dependency-analyzer.ts

@@ -0,0 +1,243 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { WorkspaceMetadata, DependencyInfo } from '../types';
+import { getUserConfig } from './config';
+
+export interface DependencyAnalysis {
+  repoName: string;
+  dependencies: string[];
+  dependents: string[];
+  missingDependencies: string[];
+}
+
+export const analyzePackageJson = async (repoPath: string): Promise<string[]> => {
+  try {
+    const packageJsonPath = path.join(repoPath, 'package.json');
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(content);
+
+    const dependencies: string[] = [];
+
+    // Check dependencies and devDependencies
+    const allDeps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies,
+    };
+
+    const { githubOrg } = 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 [];
+  }
+};
+
+export const analyzeImports = async (repoPath: string): Promise<string[]> => {
+  try {
+    const dependencies: Set<string> = 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 [];
+  }
+};
+
+export const analyzeDockerfile = async (repoPath: string): Promise<string[]> => {
+  try {
+    const dockerfilePath = path.join(repoPath, 'Dockerfile');
+    const content = await fs.readFile(dockerfilePath, 'utf-8');
+
+    const dependencies: string[] = [];
+    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 } = getUserConfig();
+      if (githubOrg && image.includes(githubOrg)) {
+        dependencies.push(image.split(':')[0].replace(`${githubOrg}-`, ''));
+      }
+    }
+
+    return dependencies;
+  } catch {
+    return [];
+  }
+};
+
+export const analyzeDockerCompose = async (repoPath: string): Promise<string[]> => {
+  try {
+    const composePath = path.join(repoPath, 'docker-compose.yml');
+    const content = await fs.readFile(composePath, 'utf-8');
+
+    const dependencies: string[] = [];
+
+    // 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 [];
+  }
+};
+
+export const analyzeDependencies = async (
+  workspacePath: string,
+  repoNames: string[]
+): Promise<Map<string, DependencyAnalysis>> => {
+  const analyses = new Map<string, DependencyAnalysis>();
+
+  for (const repoName of repoNames) {
+    const repoPath = path.join(workspacePath, repoName);
+
+    const [packageDeps, dockerDeps, composeDeps] = await Promise.all([
+      analyzePackageJson(repoPath),
+      analyzeDockerfile(repoPath),
+      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;
+};
+
+export const detectCircularDependencies = (
+  analyses: Map<string, DependencyAnalysis>
+): string[][] => {
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+  const cycles: string[][] = [];
+
+  const dfs = (repo: string, path: string[]): void => {
+    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;
+};
+
+export const generateMermaidDiagram = (analyses: Map<string, DependencyAnalysis>): string => {
+  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');
+};
+
+export const updateWorkspaceMetadata = (
+  metadata: WorkspaceMetadata,
+  analyses: Map<string, DependencyAnalysis>
+): WorkspaceMetadata => {
+  const dependencies: { [repoName: string]: DependencyInfo } = {};
+
+  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(),
+  };
+};

package/src/utils/diff-operations.ts

@@ -0,0 +1,59 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs/promises';
+
+const execAsync = promisify(exec);
+
+export interface DiffStats {
+  files: number;
+  insertions: number;
+  deletions: number;
+}
+
+export interface RepoDiff {
+  repo: string;
+  staged: DiffStats;
+  unstaged: DiffStats;
+  error?: string;
+}
+
+export function parseDiffStat(output: string): DiffStats {
+  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,
+  };
+}
+
+export async function getRepoDiff(repoPath: string, repoName: string): Promise<RepoDiff> {
+  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 as { stdout: string }).stdout),
+      staged: parseDiffStat((stagedResult as { stdout: string }).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/src/utils/doc-generator.ts

@@ -0,0 +1,187 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { WorkspaceMetadata } from '../types';
+import { generateMermaidDiagram } from './dependency-analyzer';
+import * as markdownTable from 'markdown-table';
+
+export const generateWorkspaceReadme = async (
+  metadata: WorkspaceMetadata,
+  workspacePath: string
+): Promise<string> => {
+  const lines: string[] = [];
+
+  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: string[][] = [
+    ['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');
+};
+
+export const generateDependencyGraph = (metadata: WorkspaceMetadata): string => {
+  const lines: string[] = [];
+
+  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 = 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');
+};
+
+export const generateRepositoryIndex = async (
+  metadata: WorkspaceMetadata,
+  workspacePath: string
+): Promise<string> => {
+  const lines: string[] = [];
+
+  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');
+};
+
+export const writeDocs = async (
+  workspacePath: string,
+  metadata: WorkspaceMetadata
+): Promise<void> => {
+  const readme = await generateWorkspaceReadme(metadata, workspacePath);
+  await fs.writeFile(path.join(workspacePath, 'WORKSPACE-README.md'), readme, 'utf-8');
+
+  const depGraph = generateDependencyGraph(metadata);
+  await fs.writeFile(path.join(workspacePath, 'DEPENDENCY-GRAPH.md'), depGraph, 'utf-8');
+
+  const repoIndex = await generateRepositoryIndex(metadata, workspacePath);
+  await fs.writeFile(path.join(workspacePath, 'REPOSITORY-INDEX.md'), repoIndex, 'utf-8');
+};