@hartvig/developer-control-center 0.8.2

package/src/cli.ts

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from './config/index.js';
+import { Runtime, detectCI } from './core/index.js';
+import { startUI } from './ui/index.js';
+
+const VERSION = '0.1.0';
+
+function printHelp(): void {
+  console.log(`
+developer-control-center v${VERSION}
+
+Usage: dcc [command] [options]
+
+Commands:
+  init                     Scaffold a developer-control-center.config.js file
+  completion <shell>       Generate shell completion script (bash|zsh|fish)
+
+Options:
+  --profile <name>         Use a specific environment profile
+  --help, -h               Show this help message
+  --version, -v            Show version number
+
+Environment:
+  DCC_PROFILE              Default profile name (overridden by --profile)
+
+Examples:
+  dcc                      Launch the TUI
+  dcc init                 Create developer-control-center.config.js in current directory
+  dcc completion bash      Generate bash completions
+`);
+}
+
+function printInitHelp(): void {
+  const config = `export default {
+  name: '${path.basename(process.cwd())}',
+  commands: [
+    {
+      id: 'dev',
+      label: 'Dev server',
+      command: 'npm run dev',
+      watch: true,
+      group: 'Development',
+    },
+    {
+      id: 'test',
+      label: 'Test',
+      command: 'npm test',
+      group: 'Development',
+    },
+    {
+      id: 'lint',
+      label: 'Lint',
+      command: 'npm run lint',
+      group: 'Development',
+    },
+    {
+      id: 'build',
+      label: 'Build',
+      command: 'npm run build',
+      group: 'Build',
+    },
+    {
+      id: 'typecheck',
+      label: 'Type check',
+      command: 'npm run typecheck',
+      group: 'Build',
+    },
+    {
+      id: 'deploy-staging',
+      label: 'Deploy to staging',
+      command: 'npm run deploy:staging',
+      confirm: true,
+      group: 'Deploy',
+    },
+    {
+      id: 'deploy-production',
+      label: 'Deploy to production',
+      command: 'npm run deploy:production',
+      confirm: true,
+      group: 'Deploy',
+    },
+  ],
+};
+`;
+  fs.writeFileSync('developer-control-center.config.js', config, 'utf-8');
+  console.log('Created developer-control-center.config.js');
+}
+
+function printCompletion(shell: string): void {
+  const bin = 'dcc';
+
+  const bash = `_${bin}() {
+  local cur words
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  words="init completion bash zsh fish --profile --help --version"
+
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "$words" -- "$cur")
+  elif [[ $COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "completion" ]]; then
+    mapfile -t COMPREPLY < <(compgen -W "bash zsh fish" -- "$cur")
+  fi
+}
+complete -F _${bin} ${bin}
+`;
+
+  const zsh = `#compdef ${bin}
+_${bin}() {
+  local -a subcommands
+  subcommands=(
+    'init:Scaffold a config file'
+    'completion:Generate shell completion script'
+  )
+
+  _arguments \\
+    '--profile[Use a specific profile]:profile' \\
+    '--help[Show help]' \\
+    '--version[Show version]' \\
+    '1: :->command' \\
+    '*: :->args'
+
+  case $state in
+    command)
+      _describe 'command' subcommands
+      ;;
+    args)
+      case $words[1] in
+        completion)
+          _arguments '2:shell:(bash zsh fish)'
+          ;;
+      esac
+      ;;
+  esac
+}
+compdef _${bin} ${bin}
+`;
+
+  const fish = `function _${bin}
+  set -l commands init completion
+
+  complete -c ${bin} -f
+
+  complete -c ${bin} -n "not __fish_seen_subcommand_from $commands" \\
+    -a init -d "Scaffold a config file"
+  complete -c ${bin} -n "not __fish_seen_subcommand_from $commands" \\
+    -a completion -d "Generate shell completion script"
+  complete -c ${bin} -n "not __fish_seen_subcommand_from $commands" \\
+    -l profile -d "Use a specific profile" -r
+  complete -c ${bin} -n "not __fish_seen_subcommand_from $commands" \\
+    -l help -s h -d "Show help"
+  complete -c ${bin} -n "not __fish_seen_subcommand_from $commands" \\
+    -l version -s v -d "Show version"
+
+  complete -c ${bin} -n "__fish_seen_subcommand_from completion" \\
+    -a bash -d "Bash completions"
+  complete -c ${bin} -n "__fish_seen_subcommand_from completion" \\
+    -a zsh -d "Zsh completions"
+  complete -c ${bin} -n "__fish_seen_subcommand_from completion" \\
+    -a fish -d "Fish completions"
+end
+`;
+
+  switch (shell) {
+    case 'bash':
+      console.log(bash.trimEnd());
+      break;
+    case 'zsh':
+      console.log(zsh.trimEnd());
+      break;
+    case 'fish':
+      console.log(fish.trimEnd());
+      break;
+    default:
+      console.error(`Unknown shell: ${shell}. Supported: bash, zsh, fish`);
+      process.exit(1);
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let configPath: string | undefined;
+  let profile: string | undefined;
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+
+  if (args[0] === 'init') {
+    printInitHelp();
+    process.exit(0);
+  }
+
+  if (args[0] === 'completion') {
+    printCompletion(args[1] || 'bash');
+    process.exit(0);
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--profile' && i + 1 < args.length) {
+      profile = args[i + 1];
+      i++;
+    } else if (!args[i].startsWith('-')) {
+      configPath = args[i];
+    }
+  }
+
+  profile = profile || process.env.DCC_PROFILE;
+
+  const ci = detectCI();
+  if (!profile && ci.isCI) {
+    profile = 'ci';
+  }
+
+  const config = await loadConfig(configPath, profile);
+  const runtime = new Runtime(config);
+  await runtime.start();
+
+  if (ci.isCI) {
+    console.error(`[dcc] detected ${ci.name}, profile: ${config.profile || 'none'}`);
+  }
+
+  if (!process.stdin.isTTY) {
+    console.error('dcc requires an interactive terminal');
+    process.exit(1);
+  }
+  console.clear();
+  await startUI(config, runtime);
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export { loadConfig, mergeCommands } from './loader.js';
+export type { ProkomCommand, ProkomConfig, ProkomPreset, ProkomProfile, ProkomPipeline, ProkomToggle } from './types.js';

package/src/config/loader.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { loadConfig } from './loader.js';
+
+describe('loadConfig', () => {
+  const configPath = path.resolve(
+    fileURLToPath(new URL('../../developer-control-center.config.js', import.meta.url)),
+  );
+
+  it('returns default config when no config file exists', async () => {
+    const cwd = process.cwd;
+    process.cwd = () => '/tmp/nonexistent' as any;
+    const config = await loadConfig();
+    expect(config.name).toBe('nonexistent');
+    expect(config.commands).toEqual([]);
+    process.cwd = cwd;
+  });
+
+  it('loads config from a custom path', async () => {
+    const config = await loadConfig(configPath);
+    expect(config.name).toBe('developer-control-center');
+    expect(config.commands.length).toBeGreaterThan(0);
+  });
+
+  it('applies profile when specified', async () => {
+    const config = await loadConfig(configPath, 'ci');
+    expect(config.profile).toBe('ci');
+  });
+});

package/src/config/loader.ts

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { ProkomConfig, ProkomCommand, ProkomPreset } from './types.js';
+
+const CONFIG_CANDIDATES = [
+  'developer-control-center.config.mjs',
+  'developer-control-center.config.cjs',
+  'developer-control-center.config.js',
+];
+
+function findConfigFile(cwd: string): string | null {
+  for (const file of CONFIG_CANDIDATES) {
+    const fullPath = path.join(cwd, file);
+    if (fs.existsSync(fullPath)) return fullPath;
+  }
+  return null;
+}
+
+async function resolvePreset(
+  name: string,
+  cwd: string,
+): Promise<ProkomPreset> {
+  if (name.startsWith('.') || name.startsWith('/')) {
+    const resolved = pathToFileURL(path.resolve(cwd, name)).href;
+    const mod = await import(resolved);
+    return mod.default || mod;
+  }
+
+  try {
+    const mod = await import(`./presets/${name}.js`);
+    return mod.default || mod;
+  } catch {
+    const mod = await import(name);
+    return mod.default || mod;
+  }
+}
+
+export function mergeCommands(
+  base: ProkomCommand[],
+  overrides: ProkomCommand[],
+): ProkomCommand[] {
+  const overrideMap = new Map<string, ProkomCommand>();
+  for (const cmd of overrides) {
+    overrideMap.set(cmd.id, cmd);
+  }
+
+  const seen = new Set<string>();
+  const merged: ProkomCommand[] = [];
+
+  for (const cmd of base) {
+    seen.add(cmd.id);
+    merged.push(overrideMap.get(cmd.id) ?? cmd);
+  }
+
+  for (const cmd of overrides) {
+    if (!seen.has(cmd.id)) {
+      seen.add(cmd.id);
+      merged.push(cmd);
+    }
+  }
+
+  return merged;
+}
+
+export async function loadConfig(
+  configPath?: string,
+  profile?: string,
+): Promise<ProkomConfig> {
+  const cwd = process.cwd();
+  const resolved = configPath || findConfigFile(cwd);
+
+  if (!resolved) {
+    return { name: path.basename(cwd), commands: [] };
+  }
+
+  const configFileDir = path.dirname(resolved);
+  let mod;
+  try {
+    mod = await import(pathToFileURL(resolved).href);
+  } catch (err) {
+    console.error(`dcc: failed to load config file ${resolved}`);
+    console.error(err instanceof Error ? err.message : String(err));
+    return { name: path.basename(cwd), commands: [] };
+  }
+  const config: ProkomConfig = mod.default || mod;
+
+  if (config.presets && config.presets.length > 0) {
+    const presetList: ProkomPreset[] = [];
+    for (const presetName of config.presets) {
+      const preset = await resolvePreset(presetName, configFileDir);
+      presetList.push(preset);
+    }
+
+    const allPresetCommands = presetList.flatMap((p) => p.commands);
+    config.commands = mergeCommands(allPresetCommands, config.commands);
+  }
+
+  config.baseCommands = [...config.commands];
+
+  if (profile && config.profiles?.[profile]) {
+    config.commands = mergeCommands(
+      config.commands,
+      config.profiles[profile].commands,
+    );
+    config.profile = profile;
+  }
+
+  if (config.pipelines) {
+    for (const pipeline of config.pipelines) {
+      config.commands.push({
+        id: pipeline.id,
+        label: `▶ ${pipeline.label}`,
+        description: `Run pipeline: ${pipeline.steps.join(' → ')}`,
+        command: '',
+        confirm: pipeline.confirm,
+        pipelineSteps: pipeline.steps,
+      });
+    }
+  }
+
+  return config;
+}

package/src/config/presets/node.ts

@@ -0,0 +1,30 @@
+export default {
+  name: 'node',
+  commands: [
+    {
+      id: 'node-test',
+      label: 'Test',
+      command: 'npm test',
+    },
+    {
+      id: 'node-build',
+      label: 'Build',
+      command: 'npm run build',
+    },
+    {
+      id: 'node-lint',
+      label: 'Lint',
+      command: 'npm run lint',
+    },
+    {
+      id: 'node-typecheck',
+      label: 'TypeCheck',
+      command: 'npx tsc --noEmit',
+    },
+    {
+      id: 'node-clean',
+      label: 'Clean',
+      command: 'rm -rf dist',
+    },
+  ],
+};

package/src/config/presets/react.ts

@@ -0,0 +1,35 @@
+export default {
+  name: 'react',
+  commands: [
+    {
+      id: 'react-dev',
+      label: 'Dev server',
+      command: 'npm run dev',
+    },
+    {
+      id: 'react-build',
+      label: 'Build',
+      command: 'npm run build',
+    },
+    {
+      id: 'react-test',
+      label: 'Test',
+      command: 'npm test',
+    },
+    {
+      id: 'react-lint',
+      label: 'Lint',
+      command: 'npm run lint',
+    },
+    {
+      id: 'react-typecheck',
+      label: 'TypeCheck',
+      command: 'npx tsc --noEmit',
+    },
+    {
+      id: 'react-preview',
+      label: 'Preview build',
+      command: 'npm run preview',
+    },
+  ],
+};

package/src/config/types.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+
+describe('type exports', () => {
+  it('can build a minimal ProkomConfig', async () => {
+    const cfg = { name: 'test', commands: [] };
+    expect(cfg.name).toBe('test');
+    expect(cfg.commands).toEqual([]);
+  });
+
+  it('can build a ProkomCommand with all optional fields', async () => {
+    const cmd = {
+      id: 'test',
+      label: 'Test',
+      command: 'echo hi',
+      confirm: true,
+      watch: false,
+      cwd: 'packages/core',
+      parallel: true,
+    };
+    expect(cmd.id).toBe('test');
+    expect(cmd.cwd).toBe('packages/core');
+    expect(cmd.parallel).toBe(true);
+  });
+});

package/src/config/types.ts

@@ -0,0 +1,52 @@
+export interface ProkomToggle {
+  start: string;
+  stop?: string;
+}
+
+export interface ProkomCommand {
+  id: string;
+  label: string;
+  description?: string;
+  command?: string;
+  toggle?: ProkomToggle;
+  confirm?: boolean;
+  input?: { message: string; placeholder?: string; default?: string };
+  onNonZeroExit?: { label: string; command: string };
+  timeout?: number;
+  watch?: boolean;
+  cwd?: string;
+  group?: string;
+  parallel?: boolean;
+  pipelineSteps?: string[];
+  parallelSteps?: string[];
+}
+
+export interface ProkomPreset {
+  name: string;
+  commands: ProkomCommand[];
+}
+
+export interface ProkomProfile {
+  commands: ProkomCommand[];
+}
+
+export interface ProkomPipeline {
+  id: string;
+  label: string;
+  steps: string[];
+  confirm?: boolean;
+}
+
+export interface ProkomConfig {
+  name: string;
+  commands: ProkomCommand[];
+  presets?: string[];
+  plugins?: string[];
+  profiles?: Record<string, ProkomProfile>;
+  profile?: string;
+  baseCommands?: ProkomCommand[];
+  notifications?: boolean;
+  pipelines?: ProkomPipeline[];
+  menuRows?: number;
+  outputRows?: number;
+}

package/src/core/ci.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { detectCI } from './ci.js';
+
+const ORIG_ENV = { ...process.env };
+
+beforeEach(() => {
+  // Clear CI-related env vars
+  for (const key of Object.keys(process.env)) {
+    if (['GITHUB_ACTIONS', 'GITLAB_CI', 'CIRCLECI', 'JENKINS_URL', 'CI'].includes(key)) {
+      delete process.env[key];
+    }
+  }
+});
+
+afterEach(() => {
+  Object.assign(process.env, ORIG_ENV);
+});
+
+describe('detectCI', () => {
+  it('returns not CI when no CI env vars', () => {
+    expect(detectCI()).toEqual({ isCI: false });
+  });
+
+  it('detects GitHub Actions', () => {
+    process.env.GITHUB_ACTIONS = 'true';
+    expect(detectCI()).toEqual({ isCI: true, name: 'GitHub Actions' });
+  });
+
+  it('detects GitLab CI', () => {
+    process.env.GITLAB_CI = 'true';
+    expect(detectCI()).toEqual({ isCI: true, name: 'GitLab CI' });
+  });
+
+  it('detects CircleCI', () => {
+    process.env.CIRCLECI = 'true';
+    expect(detectCI()).toEqual({ isCI: true, name: 'CircleCI' });
+  });
+
+  it('detects Jenkins', () => {
+    process.env.JENKINS_URL = 'http://jenkins.example.com';
+    expect(detectCI()).toEqual({ isCI: true, name: 'Jenkins' });
+  });
+
+  it('detects generic CI', () => {
+    process.env.CI = 'true';
+    expect(detectCI()).toEqual({ isCI: true, name: 'CI' });
+  });
+
+  it('prefers specific CI over generic', () => {
+    process.env.CI = 'true';
+    process.env.GITHUB_ACTIONS = 'true';
+    expect(detectCI()).toEqual({ isCI: true, name: 'GitHub Actions' });
+  });
+});

package/src/core/ci.ts

@@ -0,0 +1,26 @@
+export interface CIInfo {
+  isCI: boolean;
+  name?: string;
+}
+
+export function detectCI(): CIInfo {
+  if (process.env.GITHUB_ACTIONS) {
+    return { isCI: true, name: 'GitHub Actions' };
+  }
+  if (process.env.GITLAB_CI) {
+    return { isCI: true, name: 'GitLab CI' };
+  }
+  if (process.env.CIRCLECI) {
+    return { isCI: true, name: 'CircleCI' };
+  }
+  if (process.env.JENKINS_URL) {
+    return { isCI: true, name: 'Jenkins' };
+  }
+  if (process.env.TF_BUILD) {
+    return { isCI: true, name: 'Azure Pipelines' };
+  }
+  if (process.env.CI) {
+    return { isCI: true, name: 'CI' };
+  }
+  return { isCI: false };
+}

package/src/core/event-bus.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { EventBus } from './event-bus.js';
+
+describe('EventBus', () => {
+  let bus: EventBus;
+
+  beforeEach(() => {
+    bus = new EventBus();
+  });
+
+  it('emits to registered listeners', () => {
+    const calls: string[] = [];
+    bus.on('test', (msg: string) => calls.push(msg));
+    bus.emit('test', 'hello');
+    expect(calls).toEqual(['hello']);
+  });
+
+  it('emits to multiple listeners', () => {
+    const results: number[] = [];
+    bus.on('count', (n: number) => results.push(n * 2));
+    bus.on('count', (n: number) => results.push(n * 3));
+    bus.emit('count', 5);
+    expect(results).toEqual([10, 15]);
+  });
+
+  it('supports off/unsubscribe', () => {
+    const calls: string[] = [];
+    const fn = (x: string) => calls.push(x);
+    bus.on('e', fn);
+    bus.emit('e', 'a');
+    bus.off('e', fn);
+    bus.emit('e', 'b');
+    expect(calls).toEqual(['a']);
+  });
+
+  it('removeAll clears all listeners', () => {
+    const calls: string[] = [];
+    bus.on('x', () => calls.push('x'));
+    bus.on('y', () => calls.push('y'));
+    bus.removeAll();
+    bus.emit('x');
+    bus.emit('y');
+    expect(calls).toEqual([]);
+  });
+
+  it('does nothing for unregistered events', () => {
+    expect(() => bus.emit('nothing')).not.toThrow();
+  });
+
+  it('passes multiple arguments', () => {
+    const args: any[] = [];
+    bus.on('multi', (...a: any[]) => args.push(a));
+    bus.emit('multi', 1, 'two', true);
+    expect(args).toEqual([[1, 'two', true]]);
+  });
+});