kodelyth-ecc 1.2.0

package/scripts/lib/orchestration-session.js

@@ -0,0 +1,299 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function stripCodeTicks(value) {
+  if (typeof value !== 'string') {
+    return value;
+  }
+
+  const trimmed = value.trim();
+  if (trimmed.startsWith('`') && trimmed.endsWith('`') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1);
+  }
+
+  return trimmed;
+}
+
+function parseSection(content, heading) {
+  if (typeof content !== 'string' || content.length === 0) {
+    return '';
+  }
+
+  const lines = content.split('\n');
+  const headingLines = new Set([`## ${heading}`, `**${heading}**`]);
+  const startIndex = lines.findIndex(line => headingLines.has(line.trim()));
+
+  if (startIndex === -1) {
+    return '';
+  }
+
+  const collected = [];
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (trimmed.startsWith('## ') || (/^\*\*.+\*\*$/.test(trimmed) && !headingLines.has(trimmed))) {
+      break;
+    }
+    collected.push(line);
+  }
+
+  return collected.join('\n').trim();
+}
+
+function parseBullets(section) {
+  if (!section) {
+    return [];
+  }
+
+  return section
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.startsWith('- '))
+    .map(line => stripCodeTicks(line.replace(/^- /, '').trim()));
+}
+
+function parseWorkerStatus(content) {
+  const status = {
+    state: null,
+    updated: null,
+    branch: null,
+    worktree: null,
+    taskFile: null,
+    handoffFile: null
+  };
+
+  if (typeof content !== 'string' || content.length === 0) {
+    return status;
+  }
+
+  for (const line of content.split('\n')) {
+    const match = line.match(/^- ([A-Za-z ]+):\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+
+    const key = match[1].trim().toLowerCase().replace(/\s+/g, '');
+    const value = stripCodeTicks(match[2]);
+
+    if (key === 'state') status.state = value;
+    if (key === 'updated') status.updated = value;
+    if (key === 'branch') status.branch = value;
+    if (key === 'worktree') status.worktree = value;
+    if (key === 'taskfile') status.taskFile = value;
+    if (key === 'handofffile') status.handoffFile = value;
+  }
+
+  return status;
+}
+
+function parseWorkerTask(content) {
+  return {
+    objective: parseSection(content, 'Objective'),
+    seedPaths: parseBullets(parseSection(content, 'Seeded Local Overlays'))
+  };
+}
+
+function parseWorkerHandoff(content) {
+  return {
+    summary: parseBullets(parseSection(content, 'Summary')),
+    validation: parseBullets(parseSection(content, 'Validation')),
+    remainingRisks: parseBullets(parseSection(content, 'Remaining Risks'))
+  };
+}
+
+function readTextIfExists(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return '';
+  }
+
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function listWorkerDirectories(coordinationDir) {
+  if (!coordinationDir || !fs.existsSync(coordinationDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(coordinationDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .filter(entry => {
+      const workerDir = path.join(coordinationDir, entry.name);
+      return ['status.md', 'task.md', 'handoff.md']
+        .some(filename => fs.existsSync(path.join(workerDir, filename)));
+    })
+    .map(entry => entry.name)
+    .sort();
+}
+
+function loadWorkerSnapshots(coordinationDir) {
+  return listWorkerDirectories(coordinationDir).map(workerSlug => {
+    const workerDir = path.join(coordinationDir, workerSlug);
+    const statusPath = path.join(workerDir, 'status.md');
+    const taskPath = path.join(workerDir, 'task.md');
+    const handoffPath = path.join(workerDir, 'handoff.md');
+
+    const status = parseWorkerStatus(readTextIfExists(statusPath));
+    const task = parseWorkerTask(readTextIfExists(taskPath));
+    const handoff = parseWorkerHandoff(readTextIfExists(handoffPath));
+
+    return {
+      workerSlug,
+      workerDir,
+      status,
+      task,
+      handoff,
+      files: {
+        status: statusPath,
+        task: taskPath,
+        handoff: handoffPath
+      }
+    };
+  });
+}
+
+function listTmuxPanes(sessionName, options = {}) {
+  const { spawnSyncImpl = spawnSync } = options;
+  const format = [
+    '#{pane_id}',
+    '#{window_index}',
+    '#{pane_index}',
+    '#{pane_title}',
+    '#{pane_current_command}',
+    '#{pane_current_path}',
+    '#{pane_active}',
+    '#{pane_dead}',
+    '#{pane_pid}'
+  ].join('\t');
+
+  const result = spawnSyncImpl('tmux', ['list-panes', '-t', sessionName, '-F', format], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  if (result.error) {
+    if (result.error.code === 'ENOENT') {
+      return [];
+    }
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    return [];
+  }
+
+  return (result.stdout || '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map(line => {
+      const [
+        paneId,
+        windowIndex,
+        paneIndex,
+        title,
+        currentCommand,
+        currentPath,
+        active,
+        dead,
+        pid
+      ] = line.split('\t');
+
+      return {
+        paneId,
+        windowIndex: Number(windowIndex),
+        paneIndex: Number(paneIndex),
+        title,
+        currentCommand,
+        currentPath,
+        active: active === '1',
+        dead: dead === '1',
+        pid: pid ? Number(pid) : null
+      };
+    });
+}
+
+function summarizeWorkerStates(workers) {
+  return workers.reduce((counts, worker) => {
+    const state = worker.status.state || 'unknown';
+    counts[state] = (counts[state] || 0) + 1;
+    return counts;
+  }, {});
+}
+
+function buildSessionSnapshot({ sessionName, coordinationDir, panes }) {
+  const workerSnapshots = loadWorkerSnapshots(coordinationDir);
+  const paneMap = new Map(panes.map(pane => [pane.title, pane]));
+
+  const workers = workerSnapshots.map(worker => ({
+    ...worker,
+    pane: paneMap.get(worker.workerSlug) || null
+  }));
+
+  return {
+    sessionName,
+    coordinationDir,
+    sessionActive: panes.length > 0,
+    paneCount: panes.length,
+    workerCount: workers.length,
+    workerStates: summarizeWorkerStates(workers),
+    panes,
+    workers
+  };
+}
+
+function resolveSnapshotTarget(targetPath, cwd = process.cwd()) {
+  const absoluteTarget = path.resolve(cwd, targetPath);
+
+  if (fs.existsSync(absoluteTarget) && fs.statSync(absoluteTarget).isFile()) {
+    const config = JSON.parse(fs.readFileSync(absoluteTarget, 'utf8'));
+    const repoRoot = path.resolve(config.repoRoot || cwd);
+    const coordinationRoot = path.resolve(
+      config.coordinationRoot || path.join(repoRoot, '.orchestration')
+    );
+
+    return {
+      sessionName: config.sessionName,
+      coordinationDir: path.join(coordinationRoot, config.sessionName),
+      repoRoot,
+      targetType: 'plan'
+    };
+  }
+
+  return {
+    sessionName: targetPath,
+    coordinationDir: path.join(cwd, '.claude', 'orchestration', targetPath),
+    repoRoot: cwd,
+    targetType: 'session'
+  };
+}
+
+function collectSessionSnapshot(targetPath, cwd = process.cwd()) {
+  const target = resolveSnapshotTarget(targetPath, cwd);
+  const panes = listTmuxPanes(target.sessionName);
+  const snapshot = buildSessionSnapshot({
+    sessionName: target.sessionName,
+    coordinationDir: target.coordinationDir,
+    panes
+  });
+
+  return {
+    ...snapshot,
+    repoRoot: target.repoRoot,
+    targetType: target.targetType
+  };
+}
+
+module.exports = {
+  buildSessionSnapshot,
+  collectSessionSnapshot,
+  listTmuxPanes,
+  loadWorkerSnapshots,
+  normalizeText: stripCodeTicks,
+  parseWorkerHandoff,
+  parseWorkerStatus,
+  parseWorkerTask,
+  resolveSnapshotTarget
+};

package/scripts/lib/package-manager.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Package Manager Detection and Selection.
+ * Supports: npm, pnpm, yarn, bun.
+ */
+
+/** Supported package manager names */
+export type PackageManagerName = 'npm' | 'pnpm' | 'yarn' | 'bun';
+
+/** Configuration for a single package manager */
+export interface PackageManagerConfig {
+  name: PackageManagerName;
+  /** Lock file name (e.g., "package-lock.json", "pnpm-lock.yaml") */
+  lockFile: string;
+  /** Install command (e.g., "npm install") */
+  installCmd: string;
+  /** Run script command prefix (e.g., "npm run", "pnpm") */
+  runCmd: string;
+  /** Execute binary command (e.g., "npx", "pnpm dlx") */
+  execCmd: string;
+  /** Test command (e.g., "npm test") */
+  testCmd: string;
+  /** Build command (e.g., "npm run build") */
+  buildCmd: string;
+  /** Dev server command (e.g., "npm run dev") */
+  devCmd: string;
+}
+
+/** How the package manager was detected */
+export type DetectionSource =
+  | 'environment'
+  | 'project-config'
+  | 'package.json'
+  | 'lock-file'
+  | 'global-config'
+  | 'default';
+
+/** Result from getPackageManager() */
+export interface PackageManagerResult {
+  name: PackageManagerName;
+  config: PackageManagerConfig;
+  source: DetectionSource;
+}
+
+/** Map of all supported package managers keyed by name */
+export const PACKAGE_MANAGERS: Record<PackageManagerName, PackageManagerConfig>;
+
+/** Priority order for lock file detection */
+export const DETECTION_PRIORITY: PackageManagerName[];
+
+export interface GetPackageManagerOptions {
+  /** Project directory to detect from (default: process.cwd()) */
+  projectDir?: string;
+}
+
+/**
+ * Get the package manager to use for the current project.
+ *
+ * Detection priority:
+ * 1. CLAUDE_PACKAGE_MANAGER environment variable
+ * 2. Project-specific config (.claude/package-manager.json)
+ * 3. package.json `packageManager` field
+ * 4. Lock file detection
+ * 5. Global user preference (~/.claude/package-manager.json)
+ * 6. Default to npm (no child processes spawned)
+ */
+export function getPackageManager(options?: GetPackageManagerOptions): PackageManagerResult;
+
+/**
+ * Set the user's globally preferred package manager.
+ * Saves to ~/.claude/package-manager.json.
+ * @throws If pmName is not a known package manager or if save fails
+ */
+export function setPreferredPackageManager(pmName: PackageManagerName): { packageManager: string; setAt: string };
+
+/**
+ * Set a project-specific preferred package manager.
+ * Saves to <projectDir>/.claude/package-manager.json.
+ * @throws If pmName is not a known package manager
+ */
+export function setProjectPackageManager(pmName: PackageManagerName, projectDir?: string): { packageManager: string; setAt: string };
+
+/**
+ * Get package managers installed on the system.
+ * WARNING: Spawns child processes for each PM check.
+ * Do NOT call during session startup hooks.
+ */
+export function getAvailablePackageManagers(): PackageManagerName[];
+
+/** Detect package manager from lock file in the given directory */
+export function detectFromLockFile(projectDir?: string): PackageManagerName | null;
+
+/** Detect package manager from package.json `packageManager` field */
+export function detectFromPackageJson(projectDir?: string): PackageManagerName | null;
+
+/**
+ * Get the full command string to run a script.
+ * @param script - Script name: "install", "test", "build", "dev", or custom
+ */
+export function getRunCommand(script: string, options?: GetPackageManagerOptions): string;
+
+/**
+ * Get the full command string to execute a package binary.
+ * @param binary - Binary name (e.g., "prettier", "eslint")
+ * @param args - Arguments to pass to the binary
+ */
+export function getExecCommand(binary: string, args?: string, options?: GetPackageManagerOptions): string;
+
+/**
+ * Get a message prompting the user to configure their package manager.
+ * Does NOT spawn child processes.
+ */
+export function getSelectionPrompt(): string;
+
+/**
+ * Generate a regex pattern string that matches commands for all package managers.
+ * @param action - Action like "dev", "install", "test", "build", or custom
+ * @returns Parenthesized alternation regex string, e.g., "(npm run dev|pnpm( run)? dev|...)"
+ */
+export function getCommandPattern(action: string): string;