scc-universal 1.1.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.js

@@ -0,0 +1,124 @@
+'use strict';
+
+/**
+ * package-manager.js — Detect the active package manager (npm/pnpm/yarn/bun).
+ *
+ * Detection order:
+ *   1. CLAUDE_PACKAGE_MANAGER env var override
+ *   2. Presence of lock files in cwd
+ *   3. npm_execpath env var set by npm/yarn
+ *   4. Fallback: npm
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const LOCK_FILES = [
+  { file: 'bun.lockb', manager: 'bun' },
+  { file: 'yarn.lock', manager: 'yarn' },
+  { file: 'pnpm-lock.yaml', manager: 'pnpm' },
+  { file: 'package-lock.json', manager: 'npm' },
+  { file: 'npm-shrinkwrap.json', manager: 'npm' },
+];
+
+/**
+ * Detect which package manager is in use.
+ * @param {string} [cwd] - Directory to check for lock files (defaults to process.cwd())
+ * @returns {'npm' | 'pnpm' | 'yarn' | 'bun'}
+ */
+function detectPackageManager(cwd) {
+  // 1. Environment override
+  const override = process.env.CLAUDE_PACKAGE_MANAGER || process.env.SCC_PACKAGE_MANAGER;
+  if (override && ['npm', 'pnpm', 'yarn', 'bun'].includes(override.toLowerCase())) {
+    return override.toLowerCase();
+  }
+
+  const dir = cwd || process.cwd();
+
+  // 2. Lock file detection
+  for (const { file, manager } of LOCK_FILES) {
+    if (fs.existsSync(path.join(dir, file))) {
+      return manager;
+    }
+  }
+
+  // 3. npm_execpath (set by npm/yarn when running scripts)
+  const execPath = process.env.npm_execpath || '';
+  if (execPath.includes('yarn')) return 'yarn';
+  if (execPath.includes('pnpm')) return 'pnpm';
+  if (execPath.includes('bun')) return 'bun';
+
+  // 4. Try to detect installed package managers by running them
+  for (const pm of ['bun', 'pnpm', 'yarn']) {
+    const result = spawnSync(pm, ['--version'], { encoding: 'utf8', timeout: 2000 });
+    if (result.status === 0) return pm;
+  }
+
+  return 'npm';
+}
+
+/**
+ * Get the install command for a given package.
+ * @param {string} pkg - Package name (e.g., 'sql.js')
+ * @param {string} [manager] - Override package manager
+ * @returns {string} Full install command string
+ */
+function getInstallCommand(pkg, manager) {
+  const pm = manager || detectPackageManager();
+  switch (pm) {
+    case 'yarn':
+      return `yarn add ${pkg}`;
+    case 'pnpm':
+      return `pnpm add ${pkg}`;
+    case 'bun':
+      return `bun add ${pkg}`;
+    case 'npm':
+    default:
+      return `npm install ${pkg}`;
+  }
+}
+
+/**
+ * Get the run command for a script.
+ * @param {string} script - Script name
+ * @param {string} [manager] - Override package manager
+ * @returns {string}
+ */
+function getRunCommand(script, manager) {
+  const pm = manager || detectPackageManager();
+  switch (pm) {
+    case 'yarn':
+      return `yarn ${script}`;
+    case 'pnpm':
+      return `pnpm run ${script}`;
+    case 'bun':
+      return `bun run ${script}`;
+    case 'npm':
+    default:
+      return `npm run ${script}`;
+  }
+}
+
+/**
+ * Get the exec/dlx command (equivalent of npx).
+ * @param {string} bin - Binary to exec
+ * @param {string} [manager] - Override package manager
+ * @returns {string}
+ */
+function getExecCommand(bin, manager) {
+  const pm = manager || detectPackageManager();
+  switch (pm) {
+    case 'yarn':
+      return `yarn dlx ${bin}`;
+    case 'pnpm':
+      return `pnpm dlx ${bin}`;
+    case 'bun':
+      return `bunx ${bin}`;
+    case 'npm':
+    default:
+      return `npx ${bin}`;
+  }
+}
+
+module.exports = { detectPackageManager, getInstallCommand, getRunCommand, getExecCommand };

package/scripts/lib/project-detect.js

@@ -0,0 +1,228 @@
+/**
+ * Salesforce project type and framework detection
+ *
+ * Cross-platform (Windows, macOS, Linux) project type detection
+ * by inspecting files in the working directory. Tailored for Salesforce
+ * projects with support for common web technologies used alongside SF.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Salesforce project detection rules.
+ * Each rule checks for marker files specific to Salesforce project types.
+ */
+const SF_PROJECT_RULES = [
+  {
+    type: 'sfdx',
+    markers: ['sfdx-project.json', 'sf-project.json'],
+    description: 'Salesforce DX Project'
+  },
+  {
+    type: 'lwc',
+    markers: ['force-app/main/default/lwc'],
+    description: 'Lightning Web Components'
+  },
+  {
+    type: 'apex',
+    markers: ['force-app/main/default/classes'],
+    description: 'Apex Classes'
+  },
+  {
+    type: 'aura',
+    markers: ['force-app/main/default/aura'],
+    description: 'Aura Components (Legacy)'
+  },
+  {
+    type: 'flow',
+    markers: ['force-app/main/default/flows'],
+    description: 'Salesforce Flows'
+  },
+  {
+    type: 'trigger',
+    markers: ['force-app/main/default/triggers'],
+    description: 'Apex Triggers'
+  }
+];
+
+/**
+ * Language detection rules for non-Salesforce languages.
+ */
+const LANGUAGE_RULES = [
+  {
+    type: 'typescript',
+    markers: ['tsconfig.json', 'tsconfig.build.json'],
+    extensions: ['.ts', '.tsx']
+  },
+  {
+    type: 'javascript',
+    markers: ['package.json', 'jsconfig.json'],
+    extensions: ['.js', '.jsx', '.mjs']
+  },
+  {
+    type: 'java',
+    markers: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+    extensions: ['.java']
+  },
+  {
+    type: 'python',
+    markers: ['requirements.txt', 'pyproject.toml', 'setup.py'],
+    extensions: ['.py']
+  }
+];
+
+/**
+ * Framework detection rules relevant to Salesforce ecosystems.
+ */
+const FRAMEWORK_RULES = [
+  // Salesforce frameworks
+  { framework: 'fflib', language: 'apex', markers: [], packageKeys: ['fflib'] },
+
+  // JavaScript/TypeScript frameworks (for LWC/Heroku)
+  { framework: 'react', language: 'typescript', markers: [], packageKeys: ['react'] },
+  { framework: 'express', language: 'javascript', markers: [], packageKeys: ['express'] },
+  { framework: 'nextjs', language: 'typescript', markers: ['next.config.js', 'next.config.mjs', 'next.config.ts'], packageKeys: ['next'] },
+
+  // Java frameworks (for SF Java SDK)
+  { framework: 'spring', language: 'java', markers: [], packageKeys: ['spring-boot', 'org.springframework'] }
+];
+
+/**
+ * Check if a file or directory exists relative to the project directory
+ */
+function fileExists(projectDir, filePath) {
+  try {
+    return fs.existsSync(path.join(projectDir, filePath));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if any file with given extension exists in the project root
+ */
+function hasFileWithExtension(projectDir, extensions) {
+  try {
+    const entries = fs.readdirSync(projectDir, { withFileTypes: true });
+    return entries.some(entry => {
+      if (!entry.isFile()) return false;
+      const ext = path.extname(entry.name);
+      return extensions.includes(ext);
+    });
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read and parse package.json dependencies
+ */
+function getPackageJsonDeps(projectDir) {
+  try {
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (!fs.existsSync(pkgPath)) return [];
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read sfdx-project.json for Salesforce project configuration
+ */
+function getSfdxProjectConfig(projectDir) {
+  try {
+    const sfdxPath = path.join(projectDir, 'sfdx-project.json');
+    if (!fs.existsSync(sfdxPath)) {
+      const sfPath = path.join(projectDir, 'sf-project.json');
+      if (!fs.existsSync(sfPath)) return null;
+      return JSON.parse(fs.readFileSync(sfPath, 'utf8'));
+    }
+    return JSON.parse(fs.readFileSync(sfdxPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect Salesforce project type, languages, and frameworks
+ * @param {string} [projectDir] - Project directory (defaults to cwd)
+ * @returns {{ sfTypes: string[], languages: string[], frameworks: string[], primary: string, projectDir: string, sfdxConfig: Object|null }}
+ */
+function detectProjectType(projectDir) {
+  projectDir = projectDir || process.cwd();
+  const sfTypes = [];
+  const languages = [];
+  const frameworks = [];
+
+  // Step 1: Detect Salesforce project types
+  for (const rule of SF_PROJECT_RULES) {
+    const hasMarker = rule.markers.some(m => fileExists(projectDir, m));
+    if (hasMarker) {
+      sfTypes.push(rule.type);
+    }
+  }
+
+  // Step 2: Detect additional languages
+  for (const rule of LANGUAGE_RULES) {
+    const hasMarker = rule.markers.some(m => fileExists(projectDir, m));
+    const hasExt = rule.extensions.length > 0 && hasFileWithExtension(projectDir, rule.extensions);
+    if (hasMarker || hasExt) {
+      languages.push(rule.type);
+    }
+  }
+
+  // Deduplicate: if both typescript and javascript detected, keep typescript
+  if (languages.includes('typescript') && languages.includes('javascript')) {
+    const idx = languages.indexOf('javascript');
+    if (idx !== -1) languages.splice(idx, 1);
+  }
+
+  // Step 3: Detect frameworks
+  const npmDeps = getPackageJsonDeps(projectDir);
+
+  for (const rule of FRAMEWORK_RULES) {
+    const hasMarker = rule.markers.some(m => fileExists(projectDir, m));
+    let hasDep = false;
+    if (rule.packageKeys.length > 0 && (rule.language === 'typescript' || rule.language === 'javascript')) {
+      hasDep = rule.packageKeys.some(key => npmDeps.some(dep => dep.toLowerCase().includes(key.toLowerCase())));
+    }
+    if (hasMarker || hasDep) {
+      frameworks.push(rule.framework);
+    }
+  }
+
+  // Step 4: Determine primary type
+  let primary = 'unknown';
+  if (sfTypes.length > 0) {
+    primary = 'salesforce';
+  } else if (frameworks.length > 0) {
+    primary = frameworks[0];
+  } else if (languages.length > 0) {
+    primary = languages[0];
+  }
+
+  // Step 5: Read SFDX project config
+  const sfdxConfig = getSfdxProjectConfig(projectDir);
+
+  return {
+    sfTypes,
+    languages,
+    frameworks,
+    primary,
+    projectDir,
+    sfdxConfig
+  };
+}
+
+module.exports = {
+  detectProjectType,
+  SF_PROJECT_RULES,
+  LANGUAGE_RULES,
+  FRAMEWORK_RULES,
+  // Exported for testing
+  getPackageJsonDeps,
+  getSfdxProjectConfig
+};