workgraph 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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.

package/README.md

@@ -0,0 +1,252 @@
+# workgraph
+
+Workspace dependency analyzer and parallel build orchestrator for npm/yarn/pnpm monorepos.
+
+## Features
+
+- **Dependency Graph Analysis** - Scans workspace projects and builds a directed dependency graph
+- **Cycle Detection** - Detects circular dependencies using DFS with coloring
+- **Affected Project Detection** - Determines which projects are affected by changes (transitive dependents)
+- **Parallel Build Planning** - Uses Kahn's algorithm to plan build waves (parallel within wave, sequential between waves)
+- **File Watching** - Monitors file changes with debouncing and triggers rebuilds
+- **Dev Server Management** - Start and manage multiple dev servers with prefixed output
+- **Concurrent Execution** - Executes builds with configurable concurrency limits
+
+## Installation
+
+```bash
+npm install -g workgraph
+# or
+npm install -D workgraph
+```
+
+## CLI Usage
+
+### Analyze Dependencies
+
+Show the dependency graph and detect cycles:
+
+```bash
+workgraph analyze
+```
+
+Output:
+```
+Analyzing workspace at: /path/to/workspace
+
+Found 6 projects
+
+Dependency Graph:
+  @myorg/api (apps/api)
+    -> @myorg/auth
+  @myorg/auth (libs/auth)
+    (no dependencies)
+  @myorg/web (apps/web)
+    -> @myorg/api
+
+No cycles detected
+```
+
+### Plan Build
+
+Show what would be built for specific changes:
+
+```bash
+# By package name
+workgraph plan -c @myorg/auth
+
+# By shorthand name
+workgraph plan -c auth
+
+# By path
+workgraph plan -c libs/auth
+
+# Multiple changes
+workgraph plan -c auth -c utils
+```
+
+Output:
+```
+Changed: @myorg/auth, @myorg/utils
+Affected: @myorg/api, @myorg/auth, @myorg/utils, @myorg/web
+
+Build Plan:
+  Wave 1 (parallel): @myorg/auth, @myorg/utils
+  Wave 2: @myorg/api
+  Wave 3: @myorg/web
+
+Total: 4 projects in 3 waves
+```
+
+### Build Affected Projects
+
+Execute the build plan:
+
+```bash
+# Build all
+workgraph build
+
+# Build affected by specific changes
+workgraph build -c auth
+
+# Dry run (show plan without executing)
+workgraph build -c auth --dry-run
+
+# With custom concurrency
+workgraph build -c auth --concurrency 2
+```
+
+### Watch Mode
+
+Watch for file changes and automatically rebuild affected projects:
+
+```bash
+# Watch all projects
+workgraph watch
+
+# Watch all, but only rebuild libs (for dev with app servers)
+workgraph watch --filter 'libs/*'
+
+# Watch libs + start app dev servers
+workgraph watch --filter 'libs/*' api web
+
+# Dry run mode
+workgraph watch --dry-run
+```
+
+**Dev workflow (single terminal):**
+```bash
+# Watch libs + start API and web dev servers
+workgraph watch --filter 'libs/*' api web
+```
+
+Output:
+```
+Starting dev server: @myorg/api
+Starting dev server: @myorg/web
+
+Watching 7 projects for changes...
+Building only projects matching: libs/* (4 projects)
+Press Ctrl+C to stop
+
+[api] [Nest] Starting Nest application...
+[web] ➜ Local: http://localhost:3000
+```
+
+## CLI Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-r, --root <path>` | Workspace root directory | `process.cwd()` |
+| `-c, --changed <projects...>` | Changed projects (names or paths) | `[]` |
+| `--concurrency <number>` | Max parallel builds | CPU count - 1 |
+| `--debounce <ms>` | Debounce time for watch mode | `200` |
+| `--dry-run` | Show plan without executing | `false` |
+| `--filter <pattern>` | Only build projects matching pattern (e.g., `libs/*`) | - |
+
+## Programmatic API
+
+```typescript
+import {
+  loadWorkspaceProjects,
+  buildGraph,
+  detectCycles,
+  getAffectedProjects,
+  planWaves,
+  executePlan,
+  createWatcher,
+} from 'workgraph';
+
+// Load workspace projects
+const projects = await loadWorkspaceProjects('/path/to/workspace');
+
+// Build dependency graph
+const graph = buildGraph(projects);
+
+// Check for cycles
+const cycles = detectCycles(graph);
+if (cycles) {
+  console.error('Cycles detected:', cycles);
+}
+
+// Get affected projects
+const changed = new Set(['@myorg/auth']);
+const affected = getAffectedProjects(changed, graph.rdeps);
+
+// Plan build waves
+const waves = planWaves(affected, graph.deps);
+// Result: [['@myorg/auth'], ['@myorg/api'], ['@myorg/web']]
+
+// Execute build plan
+const result = await executePlan(waves, projects, '/path/to/workspace', {
+  concurrency: 4,
+  dryRun: false,
+});
+```
+
+## Algorithm Details
+
+### Dependency Graph
+
+The library builds two maps:
+- `deps[A] = Set<B>` - A depends on B
+- `rdeps[B] = Set<A>` - B is a dependency of A (reverse graph)
+
+Dependencies are collected from:
+- `dependencies`
+- `devDependencies`
+- `peerDependencies`
+- `optionalDependencies`
+
+### Cycle Detection
+
+Uses DFS with three-color marking:
+- WHITE (0): Unvisited
+- GRAY (1): Currently visiting (in stack)
+- BLACK (2): Fully visited
+
+A back edge to a GRAY node indicates a cycle.
+
+### Wave Planning (Kahn's Algorithm)
+
+1. Build induced subgraph from affected projects
+2. Calculate in-degree for each node (count of unbuilt dependencies)
+3. Repeat until all nodes processed:
+   - Wave N = all nodes with in-degree 0
+   - Remove wave nodes and decrement dependents' in-degrees
+
+Projects in the same wave have no dependencies on each other and can be built in parallel.
+
+### Affected Detection
+
+Uses BFS on the reverse dependency graph:
+1. Start with changed projects
+2. Add all transitive dependents via `rdeps`
+3. Result includes original changes + all projects that depend on them
+
+## Ignored Paths
+
+The watcher ignores these patterns by default:
+- `**/node_modules/**`
+- `**/dist/**`
+- `**/.angular/**`
+- `**/.nx/**`
+- `**/coverage/**`
+- `**/*.log`
+- `**/.git/**`
+- `**/tmp/**`
+- `**/.cache/**`
+
+## Root Config Changes
+
+Changes to root configuration files trigger a rebuild of all projects:
+- `package.json`
+- `package-lock.json`
+- `pnpm-lock.yaml`
+- `yarn.lock`
+- `tsconfig.json`
+- `tsconfig.base.json`
+
+## License
+
+MIT

package/dist/affected.d.ts

@@ -0,0 +1,7 @@
+import { DependencyGraph, Project } from './types';
+export declare function getAffectedProjects(changedProjects: Set<string>, rdeps: Map<string, Set<string>>): Set<string>;
+export declare function getChangedProjectsFromFiles(changedFiles: string[], projects: Map<string, Project>, root: string): {
+    changedProjects: Set<string>;
+    isGlobalChange: boolean;
+};
+export declare function resolveProjectNames(projectIdentifiers: string[], graph: DependencyGraph): Set<string>;

package/dist/affected.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAffectedProjects = getAffectedProjects;
+exports.getChangedProjectsFromFiles = getChangedProjectsFromFiles;
+exports.resolveProjectNames = resolveProjectNames;
+const workspace_1 = require("./workspace");
+function getAffectedProjects(changedProjects, rdeps) {
+    const affected = new Set();
+    const queue = [...changedProjects];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (affected.has(current))
+            continue;
+        affected.add(current);
+        const dependents = rdeps.get(current) || new Set();
+        for (const dependent of dependents) {
+            if (!affected.has(dependent)) {
+                queue.push(dependent);
+            }
+        }
+    }
+    return affected;
+}
+function getChangedProjectsFromFiles(changedFiles, projects, root) {
+    const changedProjects = new Set();
+    let isGlobalChange = false;
+    for (const file of changedFiles) {
+        if ((0, workspace_1.isRootConfig)(file, root)) {
+            isGlobalChange = true;
+            continue;
+        }
+        const project = (0, workspace_1.getProjectFromPath)(file, projects, root);
+        if (project) {
+            changedProjects.add(project);
+        }
+    }
+    return { changedProjects, isGlobalChange };
+}
+function resolveProjectNames(projectIdentifiers, graph) {
+    const resolved = new Set();
+    for (const identifier of projectIdentifiers) {
+        if (graph.projects.has(identifier)) {
+            resolved.add(identifier);
+            continue;
+        }
+        for (const [name, project] of graph.projects) {
+            if (project.path === identifier || project.absolutePath === identifier) {
+                resolved.add(name);
+                break;
+            }
+        }
+        for (const name of graph.projects.keys()) {
+            if (name.endsWith('/' + identifier) || name === identifier) {
+                resolved.add(name);
+                break;
+            }
+        }
+    }
+    return resolved;
+}
+//# sourceMappingURL=affected.js.map

package/dist/affected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"affected.js","sourceRoot":"","sources":["../src/affected.ts"],"names":[],"mappings":";;AAGA,kDAsBC;AAED,kEAqBC;AAED,kDA+BC;AAhFD,2CAA+D;AAE/D,SAAgB,mBAAmB,CACjC,eAA4B,EAC5B,KAA+B;IAE/B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,KAAK,GAAG,CAAC,GAAG,eAAe,CAAC,CAAC;IAEnC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACxB,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;QAE/B,IAAI,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;YAAE,SAAS;QACpC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAEtB,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC;QACnD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC7B,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACxB,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAgB,2BAA2B,CACzC,YAAsB,EACtB,QAA8B,EAC9B,IAAY;IAEZ,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;IAC1C,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;QAChC,IAAI,IAAA,wBAAY,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YAC7B,cAAc,GAAG,IAAI,CAAC;YACtB,SAAS;QACX,CAAC;QAED,MAAM,OAAO,GAAG,IAAA,8BAAkB,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACzD,IAAI,OAAO,EAAE,CAAC;YACZ,eAAe,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;AAC7C,CAAC;AAED,SAAgB,mBAAmB,CACjC,kBAA4B,EAC5B,KAAsB;IAEtB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnC,KAAK,MAAM,UAAU,IAAI,kBAAkB,EAAE,CAAC;QAE5C,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;YACnC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YACzB,SAAS;QACX,CAAC;QAGD,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC7C,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;gBACvE,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACnB,MAAM;YACR,CAAC;QACH,CAAC;QAGD,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;YACzC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;gBAC3D,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACnB,MAAM;YACR,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const workspace_1 = require("./workspace");
+const graph_1 = require("./graph");
+const affected_1 = require("./affected");
+const planner_1 = require("./planner");
+const watcher_1 = require("./watcher");
+const executor_1 = require("./executor");
+const program = new commander_1.Command();
+program
+    .name('workgraph')
+    .description('Lightweight workspace dependency graph and parallel build orchestrator for monorepos')
+    .version('0.0.1');
+program
+    .command('analyze')
+    .description('Analyze workspace dependencies and show graph')
+    .option('-r, --root <path>', 'Workspace root directory', process.cwd())
+    .action(async (options) => {
+    try {
+        const root = path.resolve(options.root);
+        console.log(`Analyzing workspace at: ${root}\n`);
+        const projects = await (0, workspace_1.loadWorkspaceProjects)(root);
+        console.log(`Found ${projects.size} projects\n`);
+        const graph = (0, graph_1.buildGraph)(projects);
+        console.log('Dependency Graph:');
+        console.log((0, graph_1.formatGraph)(graph));
+        console.log();
+        const cycles = (0, graph_1.detectCycles)(graph);
+        if (cycles) {
+            console.log('Cycles detected:');
+            for (const cycle of cycles) {
+                console.log(`  ${cycle.join(' -> ')}`);
+            }
+            process.exit(1);
+        }
+        else {
+            console.log('No cycles detected');
+        }
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('plan')
+    .description('Show build plan for changed projects')
+    .option('-r, --root <path>', 'Workspace root directory', process.cwd())
+    .option('-c, --changed <projects...>', 'Changed projects (names or paths)', [])
+    .action(async (options) => {
+    try {
+        const root = path.resolve(options.root);
+        const projects = await (0, workspace_1.loadWorkspaceProjects)(root);
+        const graph = (0, graph_1.buildGraph)(projects);
+        const cycles = (0, graph_1.detectCycles)(graph);
+        if (cycles) {
+            console.error('Cannot plan: cycles detected in dependency graph');
+            process.exit(1);
+        }
+        let changedProjects;
+        if (options.changed.length === 0) {
+            console.log('No --changed specified, showing plan for all projects\n');
+            changedProjects = new Set(projects.keys());
+        }
+        else {
+            changedProjects = (0, affected_1.resolveProjectNames)(options.changed, graph);
+            if (changedProjects.size === 0) {
+                console.error('Could not resolve any projects from:', options.changed);
+                process.exit(1);
+            }
+            console.log(`Changed: ${[...changedProjects].join(', ')}\n`);
+        }
+        const affected = (0, affected_1.getAffectedProjects)(changedProjects, graph.rdeps);
+        const plan = (0, planner_1.createBuildPlan)(affected, graph.deps);
+        console.log((0, planner_1.formatBuildPlan)(plan));
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('build')
+    .description('Build affected projects')
+    .option('-r, --root <path>', 'Workspace root directory', process.cwd())
+    .option('-c, --changed <projects...>', 'Changed projects (names or paths)', [])
+    .option('--concurrency <number>', 'Max parallel builds', String(4))
+    .option('--dry-run', 'Show what would be built without executing')
+    .action(async (options) => {
+    try {
+        const root = path.resolve(options.root);
+        const projects = await (0, workspace_1.loadWorkspaceProjects)(root);
+        const graph = (0, graph_1.buildGraph)(projects);
+        const cycles = (0, graph_1.detectCycles)(graph);
+        if (cycles) {
+            console.error('Cannot build: cycles detected in dependency graph');
+            process.exit(1);
+        }
+        let changedProjects;
+        if (options.changed.length === 0) {
+            changedProjects = new Set(projects.keys());
+        }
+        else {
+            changedProjects = (0, affected_1.resolveProjectNames)(options.changed, graph);
+        }
+        const affected = (0, affected_1.getAffectedProjects)(changedProjects, graph.rdeps);
+        const plan = (0, planner_1.createBuildPlan)(affected, graph.deps);
+        console.log((0, planner_1.formatBuildPlan)(plan));
+        console.log();
+        if (plan.waves.length === 0) {
+            console.log('Nothing to build');
+            return;
+        }
+        const result = await (0, executor_1.executePlan)(plan.waves, projects, root, {
+            concurrency: parseInt(options.concurrency, 10),
+            dryRun: options.dryRun,
+            onStart: (project) => {
+                console.log(`[${(0, watcher_1.formatTimestamp)()}] Building: ${project}`);
+            },
+            onComplete: (result) => {
+                const status = result.success ? 'done' : 'FAILED';
+                console.log(`[${(0, watcher_1.formatTimestamp)()}] ${result.project}: ${status} (${result.duration}ms)`);
+                if (!result.success && result.error) {
+                    console.error(result.error);
+                }
+            },
+        });
+        console.log();
+        if (result.success) {
+            console.log(`Build complete in ${result.duration}ms`);
+        }
+        else {
+            console.error(`Build failed after ${result.duration}ms`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program
+    .command('watch')
+    .description('Watch for changes and rebuild affected projects')
+    .argument('[apps...]', 'Apps to run dev servers for (e.g., api web-angular)')
+    .option('-r, --root <path>', 'Workspace root directory', process.cwd())
+    .option('--concurrency <number>', 'Max parallel builds', String(4))
+    .option('--debounce <ms>', 'Debounce time in milliseconds', String(200))
+    .option('--dry-run', 'Show what would be built without executing')
+    .option('--filter <pattern>', 'Only build projects matching pattern (e.g., "libs/*")')
+    .action(async (apps, options) => {
+    try {
+        const root = path.resolve(options.root);
+        const projects = await (0, workspace_1.loadWorkspaceProjects)(root);
+        const graph = (0, graph_1.buildGraph)(projects);
+        const cycles = (0, graph_1.detectCycles)(graph);
+        if (cycles) {
+            console.error('Cannot watch: cycles detected in dependency graph');
+            process.exit(1);
+        }
+        const devProcesses = [];
+        if (apps.length > 0) {
+            const resolvedApps = (0, affected_1.resolveProjectNames)(apps, graph);
+            if (resolvedApps.size === 0) {
+                console.error('Could not resolve any apps from:', apps);
+                process.exit(1);
+            }
+            for (const appName of resolvedApps) {
+                const project = projects.get(appName);
+                if (!project)
+                    continue;
+                const hasDevScript = project.packageJson.scripts?.dev;
+                if (!hasDevScript) {
+                    console.warn(`Warning: ${appName} has no dev script, skipping`);
+                    continue;
+                }
+                console.log(`Starting dev server: ${appName}`);
+                const proc = (0, child_process_1.spawn)('npm', ['run', 'dev', '-w', appName], {
+                    cwd: root,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    shell: true,
+                });
+                const shortName = appName.includes('/') ? appName.split('/').pop() : appName;
+                const prefix = `[${shortName}]`;
+                proc.stdout?.on('data', (data) => {
+                    const lines = data.toString().trim().split('\n');
+                    for (const line of lines) {
+                        console.log(`${prefix} ${line}`);
+                    }
+                });
+                proc.stderr?.on('data', (data) => {
+                    const lines = data.toString().trim().split('\n');
+                    for (const line of lines) {
+                        console.error(`${prefix} ${line}`);
+                    }
+                });
+                proc.on('close', (code) => {
+                    console.log(`${prefix} exited with code ${code}`);
+                });
+                devProcesses.push(proc);
+            }
+            const cleanup = () => {
+                for (const proc of devProcesses) {
+                    proc.kill();
+                }
+                process.exit(0);
+            };
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+            console.log();
+        }
+        const filterPattern = options.filter;
+        const matchesFilter = (projectName) => {
+            if (!filterPattern)
+                return true;
+            const project = projects.get(projectName);
+            if (!project)
+                return false;
+            if (filterPattern.includes('*')) {
+                const regex = new RegExp('^' + filterPattern.replace(/\*/g, '.*') + '$');
+                return regex.test(project.path);
+            }
+            return project.path.startsWith(filterPattern) || projectName.includes(filterPattern);
+        };
+        const filteredCount = filterPattern
+            ? [...projects.keys()].filter(matchesFilter).length
+            : projects.size;
+        console.log(`Watching ${projects.size} projects for changes...`);
+        if (filterPattern) {
+            console.log(`Building only projects matching: ${filterPattern} (${filteredCount} projects)`);
+        }
+        console.log('Press Ctrl+C to stop\n');
+        let isBuilding = false;
+        let pendingChanges = null;
+        const handleChanges = async (changedProjects) => {
+            if (isBuilding) {
+                pendingChanges = pendingChanges || new Set();
+                for (const p of changedProjects) {
+                    pendingChanges.add(p);
+                }
+                return;
+            }
+            isBuilding = true;
+            console.log(`[${(0, watcher_1.formatTimestamp)()}] Changes detected: ${[...changedProjects].join(', ')}`);
+            const affected = (0, affected_1.getAffectedProjects)(changedProjects, graph.rdeps);
+            const filteredAffected = new Set([...affected].filter(matchesFilter));
+            if (filteredAffected.size === 0) {
+                console.log(`[${(0, watcher_1.formatTimestamp)()}] No matching projects to build\n`);
+                isBuilding = false;
+                return;
+            }
+            const plan = (0, planner_1.createBuildPlan)(filteredAffected, graph.deps);
+            console.log(`[${(0, watcher_1.formatTimestamp)()}] Building: ${[...filteredAffected].join(', ')}`);
+            if (plan.waves.length > 0) {
+                const result = await (0, executor_1.executePlan)(plan.waves, projects, root, {
+                    concurrency: parseInt(options.concurrency, 10),
+                    dryRun: options.dryRun,
+                    onStart: (project) => {
+                        console.log(`[${(0, watcher_1.formatTimestamp)()}] Building: ${project}`);
+                    },
+                    onComplete: (buildResult) => {
+                        const status = buildResult.success ? 'done' : 'FAILED';
+                        console.log(`[${(0, watcher_1.formatTimestamp)()}] ${buildResult.project}: ${status} (${buildResult.duration}ms)`);
+                    },
+                });
+                if (result.success) {
+                    console.log(`[${(0, watcher_1.formatTimestamp)()}] Build complete\n`);
+                }
+                else {
+                    console.error(`[${(0, watcher_1.formatTimestamp)()}] Build failed\n`);
+                }
+            }
+            isBuilding = false;
+            if (pendingChanges && pendingChanges.size > 0) {
+                const next = pendingChanges;
+                pendingChanges = null;
+                await handleChanges(next);
+            }
+        };
+        (0, watcher_1.createWatcher)({
+            root,
+            debounceMs: parseInt(options.debounce, 10),
+            onChange: handleChanges,
+        }, projects);
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map