@hartvig/developer-control-center 0.8.2

package/src/core/workspaces.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+import { detectWorkspaces } from './workspaces.js';
+
+describe('detectWorkspaces', () => {
+  const testDir = '/tmp/dcc-test-workspaces';
+
+  beforeEach(() => {
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  function writePackageJson(dir: string, content: object) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify(content));
+  }
+
+  it('returns empty when no workspaces defined', () => {
+    writePackageJson(testDir, { name: 'root' });
+    expect(detectWorkspaces(testDir)).toEqual([]);
+  });
+
+  it('discovers packages from glob pattern', () => {
+    writePackageJson(testDir, { name: 'root', workspaces: ['packages/*'] });
+    writePackageJson(path.join(testDir, 'packages/a'), { name: '@scope/a' });
+    writePackageJson(path.join(testDir, 'packages/b'), { name: '@scope/b' });
+    const ws = detectWorkspaces(testDir);
+    expect(ws.length).toBe(2);
+    expect(ws.find((w) => w.name === '@scope/a')).toBeTruthy();
+    expect(ws.find((w) => w.name === '@scope/b')).toBeTruthy();
+  });
+
+  it('discovers packages from explicit paths', () => {
+    writePackageJson(testDir, { name: 'root', workspaces: ['libs/x'] });
+    writePackageJson(path.join(testDir, 'libs/x'), { name: 'lib-x' });
+    const ws = detectWorkspaces(testDir);
+    expect(ws.length).toBe(1);
+    expect(ws[0].name).toBe('lib-x');
+    expect(ws[0].path).toBe('libs/x');
+  });
+
+  it('uses directory name as fallback when no package name', () => {
+    writePackageJson(testDir, { name: 'root', workspaces: ['pkgs/*'] });
+    fs.mkdirSync(path.join(testDir, 'pkgs/foo'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'pkgs/foo/package.json'), '{}');
+    const ws = detectWorkspaces(testDir);
+    expect(ws.length).toBe(1);
+    expect(ws[0].name).toBe('foo');
+  });
+
+  it('returns empty when workspaces glob matches nothing', () => {
+    writePackageJson(testDir, { name: 'root', workspaces: ['nowhere/*'] });
+    expect(detectWorkspaces(testDir)).toEqual([]);
+  });
+
+  it('handles bad JSON gracefully', () => {
+    writePackageJson(testDir, { name: 'root', workspaces: ['packages/*'] });
+    fs.mkdirSync(path.join(testDir, 'packages/bad'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, 'packages/bad/package.json'), '{invalid');
+    const ws = detectWorkspaces(testDir);
+    expect(ws.length).toBe(1);
+    expect(ws[0].name).toBe('bad');
+  });
+
+  it('handles missing root package.json gracefully', () => {
+    expect(detectWorkspaces('/tmp/nonexistent-dir')).toEqual([]);
+  });
+});

package/src/core/workspaces.ts

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+
+export interface WorkspacePackage {
+  name: string;
+  path: string;
+}
+
+export function detectWorkspaces(rootDir: string): WorkspacePackage[] {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8'),
+    );
+    const workspaces = pkg.workspaces;
+    if (!workspaces) return [];
+
+    const patterns: string[] = Array.isArray(workspaces)
+      ? workspaces
+      : workspaces.packages || [];
+
+    const found = new Map<string, WorkspacePackage>();
+
+    for (const pattern of patterns) {
+      const starIdx = pattern.indexOf('*');
+      if (starIdx !== -1) {
+        const prefix = pattern.slice(0, starIdx);
+        const fullDir = path.join(rootDir, prefix);
+        if (fs.existsSync(fullDir)) {
+          for (const entry of fs.readdirSync(fullDir, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+              const pkgPath = path.join(rootDir, prefix, entry.name);
+              addPackage(found, rootDir, pkgPath, entry.name);
+            }
+          }
+        }
+      } else {
+        const pkgPath = path.join(rootDir, pattern);
+        if (fs.existsSync(pkgPath)) {
+          const name = path.basename(pkgPath);
+          addPackage(found, rootDir, pkgPath, name);
+        }
+      }
+    }
+
+    return Array.from(found.values());
+  } catch {
+    return [];
+  }
+}
+
+function addPackage(
+  found: Map<string, WorkspacePackage>,
+  rootDir: string,
+  pkgPath: string,
+  fallbackName: string,
+): void {
+  const pkgJsonPath = path.join(pkgPath, 'package.json');
+  let name = fallbackName;
+  if (fs.existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+      name = pkgJson.name || fallbackName;
+    } catch {
+      // use fallback
+    }
+  }
+  if (!found.has(name)) {
+    found.set(name, {
+      name,
+      path: path.relative(rootDir, pkgPath),
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { loadConfig, mergeCommands } from './config/index.js';
+export type { ProkomCommand, ProkomConfig, ProkomPreset, ProkomProfile, ProkomPipeline, ProkomToggle } from './config/types.js';
+export { Runtime } from './core/index.js';
+export { EventBus } from './core/event-bus.js';
+export { TaskRunner } from './core/task-runner.js';
+export type { WorkspacePackage } from './core/workspaces.js';
+export { detectWorkspaces } from './core/workspaces.js';
+export type { CIInfo } from './core/ci.js';
+export { detectCI } from './core/ci.js';
+export { sendNotification } from './core/notifier.js';
+export { StatusStore } from './status/index.js';
+export type { TaskState, TaskStatus } from './status/types.js';
+export { PluginManager } from './plugins/index.js';
+export type { Plugin, PluginHooks } from './plugins/types.js';
+export { startUI } from './ui/index.js';

package/src/plugins/index.ts

@@ -0,0 +1,2 @@
+export { PluginManager } from './manager.js';
+export type { Plugin, PluginHooks } from './types.js';

package/src/plugins/manager.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { PluginManager } from './manager.js';
+import type { Plugin } from './types.js';
+
+describe('PluginManager', () => {
+  let pm: PluginManager;
+
+  beforeEach(() => {
+    pm = new PluginManager();
+  });
+
+  it('registers and retrieves a plugin', () => {
+    pm.register({ id: 'p1', name: 'Plugin 1' });
+    expect(pm.get('p1')?.name).toBe('Plugin 1');
+  });
+
+  it('returns all plugins', () => {
+    pm.register({ id: 'a', name: 'A' });
+    pm.register({ id: 'b', name: 'B' });
+    expect(pm.getAll().length).toBe(2);
+  });
+
+  it('removes a plugin', () => {
+    pm.register({ id: 'x', name: 'X' });
+    expect(pm.remove('x')).toBe(true);
+    expect(pm.get('x')).toBeUndefined();
+  });
+
+  it('returns false when removing nonexistent plugin', () => {
+    expect(pm.remove('nope')).toBe(false);
+  });
+
+  it('executes a hook on all registered plugins', async () => {
+    const calls: string[] = [];
+    pm.register({
+      id: 'a',
+      name: 'A',
+      hooks: { beforeRun: () => { calls.push('a-before'); } },
+    });
+    pm.register({
+      id: 'b',
+      name: 'B',
+      hooks: { beforeRun: () => { calls.push('b-before'); } },
+    });
+    await pm.executeHook('beforeRun', { id: 'test', label: 'T', command: 't' });
+    expect(calls).toEqual(['a-before', 'b-before']);
+  });
+
+  it('handles async hooks', async () => {
+    const order: number[] = [];
+    pm.register({
+      id: 'slow',
+      name: 'Slow',
+      hooks: {
+        beforeRun: async () => {
+          await new Promise((r) => setTimeout(r, 10));
+          order.push(1);
+        },
+      },
+    });
+    pm.register({
+      id: 'fast',
+      name: 'Fast',
+      hooks: { beforeRun: () => { order.push(2); } },
+    });
+    await pm.executeHook('beforeRun', { id: 'x', label: 'X', command: 'x' });
+    expect(order).toEqual([1, 2]);
+  });
+
+  it('does not throw when a hook fails', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    pm.register({
+      id: 'bad',
+      name: 'Bad',
+      hooks: { beforeRun: () => { throw new Error('fail'); } },
+    });
+    await expect(
+      pm.executeHook('beforeRun', { id: 'x', label: 'X', command: 'x' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('skips plugin with no hooks for the requested hook', async () => {
+    pm.register({ id: 'none', name: 'None' });
+    await pm.executeHook('beforeRun', { id: 'x', label: 'X', command: 'x' });
+  });
+
+  it('loads nothing when pluginNames is empty', async () => {
+    await pm.loadFromConfig();
+    await pm.loadFromConfig([]);
+    expect(pm.getAll().length).toBe(0);
+  });
+});

package/src/plugins/manager.ts

@@ -0,0 +1,54 @@
+import { Plugin, PluginHooks } from './types.js';
+
+type HookName = keyof PluginHooks;
+
+export class PluginManager {
+  private plugins = new Map<string, Plugin>();
+
+  register(plugin: Plugin): void {
+    this.plugins.set(plugin.id, plugin);
+  }
+
+  get(id: string): Plugin | undefined {
+    return this.plugins.get(id);
+  }
+
+  getAll(): Plugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  remove(id: string): boolean {
+    return this.plugins.delete(id);
+  }
+
+  async executeHook<K extends HookName>(
+    hook: K,
+    ...args: Parameters<NonNullable<PluginHooks[K]>>
+  ): Promise<void> {
+    for (const plugin of this.plugins.values()) {
+      const fn = plugin.hooks?.[hook] as
+        | ((...a: any[]) => void | Promise<void>)
+        | undefined;
+      if (fn) {
+        try {
+          await Promise.resolve(fn(...args));
+        } catch (e) {
+          console.error(`Plugin ${plugin.id} ${hook} error:`, e);
+        }
+      }
+    }
+  }
+
+  async loadFromConfig(pluginNames?: string[]): Promise<void> {
+    if (!pluginNames?.length) return;
+    for (const name of pluginNames) {
+      try {
+        const mod = await import(name);
+        const p: Plugin = mod.default || mod;
+        this.register(p);
+      } catch (e) {
+        console.error(`Failed to load plugin "${name}":`, e);
+      }
+    }
+  }
+}

package/src/plugins/types.ts

@@ -0,0 +1,18 @@
+import { ProkomCommand } from '../config/types.js';
+
+export interface PluginHooks {
+  beforeRun?: (command: ProkomCommand) => void | Promise<void>;
+  afterRun?: (
+    command: ProkomCommand,
+    result: { exitCode?: number; status: string },
+  ) => void | Promise<void>;
+  onOutput?: (commandId: string, text: string) => void | Promise<void>;
+  onError?: (commandId: string, error: Error) => void | Promise<void>;
+}
+
+export interface Plugin {
+  id: string;
+  name: string;
+  version?: string;
+  hooks?: PluginHooks;
+}

package/src/status/index.ts

@@ -0,0 +1,2 @@
+export { StatusStore } from './store.js';
+export type { TaskState, TaskStatus } from './types.js';

package/src/status/store.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import fs from 'fs';
+import { StatusStore } from './store.js';
+
+describe('StatusStore', () => {
+  let store: StatusStore;
+
+  beforeEach(() => {
+    store = new StatusStore();
+  });
+
+  it('starts empty', () => {
+    expect(store.getAllTasks().size).toBe(0);
+  });
+
+  it('stores and retrieves a task', () => {
+    store.updateTask('build', {
+      id: 'build',
+      label: 'Build',
+      status: 'running',
+      output: '',
+    });
+    const task = store.getTask('build');
+    expect(task?.label).toBe('Build');
+    expect(task?.status).toBe('running');
+  });
+
+  it('updates an existing task', () => {
+    store.updateTask('build', {
+      id: 'build',
+      label: 'Build',
+      status: 'running',
+      output: 'start',
+    });
+    store.updateTask('build', { output: 'start\nprogress' });
+    expect(store.getTask('build')?.output).toBe('start\nprogress');
+  });
+
+  it('clears all tasks', () => {
+    store.updateTask('a', { id: 'a', label: 'A', status: 'running' });
+    store.updateTask('b', { id: 'b', label: 'B', status: 'success' });
+    expect(store.getAllTasks().size).toBe(2);
+    store.clear();
+    expect(store.getAllTasks().size).toBe(0);
+  });
+
+  it('prunes completed tasks but keeps running ones', () => {
+    store.updateTask('running-task', { id: 'running-task', label: 'Running', status: 'running' });
+    store.updateTask('done-task', { id: 'done-task', label: 'Done', status: 'success' });
+    store.updateTask('failed-task', { id: 'failed-task', label: 'Failed', status: 'failure' });
+    expect(store.getAllTasks().size).toBe(3);
+    store.pruneCompleted();
+    expect(store.getAllTasks().size).toBe(1);
+    expect(store.getTask('running-task')).toBeDefined();
+    expect(store.getTask('done-task')).toBeUndefined();
+    expect(store.getTask('failed-task')).toBeUndefined();
+  });
+
+  it('pruneCompleted removes nothing when all tasks are running', () => {
+    store.updateTask('a', { id: 'a', label: 'A', status: 'running' });
+    store.updateTask('b', { id: 'b', label: 'B', status: 'running' });
+    store.pruneCompleted();
+    expect(store.getAllTasks().size).toBe(2);
+  });
+
+  it('notifies subscribers on update', () => {
+    const updates: number[] = [];
+    store.subscribe((tasks) => updates.push(tasks.size));
+    store.updateTask('x', { id: 'x', label: 'X', status: 'running' });
+    expect(updates).toEqual([1]);
+  });
+
+  it('unsubscribes correctly', () => {
+    const updates: number[] = [];
+    const unsub = store.subscribe((tasks) => updates.push(tasks.size));
+    unsub();
+    store.updateTask('x', { id: 'x', label: 'X', status: 'running' });
+    expect(updates).toEqual([]);
+  });
+
+  it('persists and loads from directory', () => {
+    const dir = '/tmp/dcc-test-store';
+    fs.mkdirSync(dir, { recursive: true });
+    store.updateTask('persist', {
+      id: 'persist',
+      label: 'Persist',
+      status: 'success',
+      exitCode: 0,
+    });
+    store.saveDir(dir);
+
+    const store2 = new StatusStore();
+    store2.loadDir(dir);
+    const task = store2.getTask('persist');
+    expect(task?.label).toBe('Persist');
+    expect(task?.status).toBe('success');
+
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('resets stale running tasks to failure on load', () => {
+    const dir = '/tmp/dcc-test-stale-store';
+    fs.mkdirSync(dir, { recursive: true });
+    const store = new StatusStore();
+    store.updateTask('stale-run', {
+      id: 'stale-run',
+      label: 'Stale Run',
+      status: 'running',
+      startTime: Date.now(),
+    });
+    store.saveDir(dir);
+
+    const store2 = new StatusStore();
+    store2.loadDir(dir);
+    const task = store2.getTask('stale-run');
+    expect(task?.status).toBe('failure');
+    expect(task?.label).toBe('Stale Run');
+    expect(typeof task?.endTime).toBe('number');
+
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});

package/src/status/store.ts

@@ -0,0 +1,88 @@
+import fs from 'fs';
+import path from 'path';
+import { TaskState } from './types.js';
+
+type Listener = (tasks: ReadonlyMap<string, TaskState>) => void;
+
+export class StatusStore {
+  private tasks = new Map<string, TaskState>();
+  private listeners = new Set<Listener>();
+
+  getTask(id: string): TaskState | undefined {
+    return this.tasks.get(id);
+  }
+
+  getAllTasks(): ReadonlyMap<string, TaskState> {
+    return new Map(this.tasks);
+  }
+
+  updateTask(id: string, update: Partial<TaskState>): void {
+    const existing = this.tasks.get(id) ?? {
+      id,
+      label: id,
+      status: 'idle' as const,
+    };
+    this.tasks.set(id, { ...existing, ...update });
+    this.notify();
+  }
+
+  clear(): void {
+    this.tasks.clear();
+    this.notify();
+  }
+
+  removeTask(id: string): void {
+    this.tasks.delete(id);
+    this.notify();
+  }
+
+  pruneCompleted(): void {
+    let changed = false;
+    for (const [id, task] of this.tasks) {
+      if (task.status !== 'running') {
+        this.tasks.delete(id);
+        changed = true;
+      }
+    }
+    if (changed) this.notify();
+  }
+
+  subscribe(listener: Listener): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  saveDir(dir: string): void {
+    const filePath = path.join(dir, 'status.json');
+    const data = JSON.stringify(Array.from(this.tasks.entries()));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, data, 'utf-8');
+  }
+
+  loadDir(dir: string): void {
+    const filePath = path.join(dir, 'status.json');
+    if (fs.existsSync(filePath)) {
+      const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8')) as [string, TaskState][];
+      const tasks = new Map(raw);
+      let changed = false;
+      for (const [id] of tasks) {
+        const task = tasks.get(id)!;
+        if (task.status === 'running') {
+          tasks.set(id, { ...task, status: 'failure', endTime: Date.now() });
+          changed = true;
+        }
+      }
+      if (changed) {
+        fs.writeFileSync(filePath, JSON.stringify(Array.from(tasks.entries())), 'utf-8');
+      }
+      this.tasks = tasks;
+      this.notify();
+    }
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) {
+      listener(new Map(this.tasks));
+    }
+  }
+}

package/src/status/types.ts

@@ -0,0 +1,12 @@
+export type TaskStatus = 'idle' | 'running' | 'success' | 'failure';
+
+export interface TaskState {
+  id: string;
+  label: string;
+  status: TaskStatus;
+  output?: string;
+  exitCode?: number;
+  startTime?: number;
+  endTime?: number;
+  watchMode?: boolean;
+}