@opengsd/gsd-core 1.2.0 → 1.3.0

package/get-shit-done/bin/lib/workstream-inventory.cjs

@@ -1,146 +0,0 @@
-'use strict';
-
-/**
- * Workstream Inventory Module
- *
- * Owns discovery and read-only projection of .planning/workstreams/* state.
- * Command handlers should render outputs from this inventory instead of
- * rescanning workstream directories directly.
- *
- * Pure projection logic lives in workstream-inventory-builder.generated.cjs.
- * This module handles I/O orchestration only.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { toPosixPath, readSubdirectories } = require('./core.cjs');
-const scanPhasePlans = require('./plan-scan.cjs');
-const { planningPaths, planningRoot, getActiveWorkstream } = require('./planning-workspace.cjs');
-const { stateExtractField } = require('./state-document.cjs');
-const { buildWorkstreamInventory, isCompletedInventory } = require('./workstream-inventory-builder.cjs');
-
-function workstreamsRoot(cwd) {
-  return path.join(planningRoot(cwd), 'workstreams');
-}
-
-function countRoadmapPhases(roadmapPath, fallbackCount) {
-  try {
-    const roadmapContent = fs.readFileSync(roadmapPath, 'utf-8');
-    const matches = roadmapContent.match(/^#{2,4}\s+Phase\s+[\w][\w.-]*/gm);
-    return matches ? matches.length : fallbackCount;
-  } catch {
-    return fallbackCount;
-  }
-}
-
-function countPhaseFiles(phaseDir) {
-  const scan = scanPhasePlans(phaseDir);
-  return { planCount: scan.planCount, summaryCount: scan.summaryCount };
-}
-
-function readStateProjection(statePath) {
-  try {
-    const stateContent = fs.readFileSync(statePath, 'utf-8');
-    return {
-      status: stateExtractField(stateContent, 'Status') || 'unknown',
-      current_phase: stateExtractField(stateContent, 'Current Phase'),
-      last_activity: stateExtractField(stateContent, 'Last Activity'),
-    };
-  } catch {
-    return {
-      status: 'unknown',
-      current_phase: null,
-      last_activity: null,
-    };
-  }
-}
-
-function sortWorkstreamInventories(inventories, activeWorkstreamName) {
-  return [...inventories].sort((a, b) => {
-    const aActive = a.name === activeWorkstreamName ? 1 : 0;
-    const bActive = b.name === activeWorkstreamName ? 1 : 0;
-    if (aActive !== bActive) {
-      return bActive - aActive;
-    }
-    return a.name.localeCompare(b.name);
-  });
-}
-
-function inspectWorkstream(cwd, name, options = {}) {
-  const wsDir = path.join(workstreamsRoot(cwd), name);
-  if (!fs.existsSync(wsDir)) return null;
-
-  const activeWorkstreamName = options.active === undefined ? getActiveWorkstream(cwd) : options.active;
-  const p = planningPaths(cwd, name);
-  const phaseDirNames = readSubdirectories(p.phases);
-
-  // Collect per-phase file counts
-  const phaseFilesCounts = phaseDirNames.map(dir => {
-    const counts = countPhaseFiles(path.join(p.phases, dir));
-    return { directory: dir, planCount: counts.planCount, summaryCount: counts.summaryCount };
-  });
-
-  return buildWorkstreamInventory({
-    name,
-    projectDir: cwd,
-    workstreamDir: wsDir,
-    phaseDirNames,
-    activeWorkstreamName,
-    phaseFilesCounts,
-    roadmapPhaseCount: countRoadmapPhases(p.roadmap, phaseDirNames.length),
-    stateProjection: readStateProjection(p.state),
-    filesExist: {
-      roadmap: fs.existsSync(p.roadmap),
-      state: fs.existsSync(p.state),
-      requirements: fs.existsSync(p.requirements),
-    },
-  });
-}
-
-function listWorkstreamInventories(cwd) {
-  const wsRoot = workstreamsRoot(cwd);
-  if (!fs.existsSync(wsRoot)) {
-    return {
-      mode: 'flat',
-      active: null,
-      workstreams: [],
-      count: 0,
-      message: 'No workstreams — operating in flat mode',
-    };
-  }
-
-  const active = getActiveWorkstream(cwd);
-  const entries = fs.readdirSync(wsRoot, { withFileTypes: true });
-  const workstreams = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const inventory = inspectWorkstream(cwd, entry.name, { active });
-    if (inventory) workstreams.push(inventory);
-  }
-
-  const ordered = sortWorkstreamInventories(workstreams, active);
-
-  return {
-    mode: 'workstream',
-    active,
-    workstreams: ordered,
-    count: ordered.length,
-  };
-}
-
-function getOtherActiveWorkstreamInventories(cwd, excludeWs) {
-  return listWorkstreamInventories(cwd).workstreams
-    .filter(inventory => inventory.name !== excludeWs)
-    .filter(inventory => !isCompletedInventory(inventory.status));
-}
-
-module.exports = {
-  countPhaseFiles,
-  countRoadmapPhases,
-  getOtherActiveWorkstreamInventories,
-  inspectWorkstream,
-  isCompletedInventory,
-  listWorkstreamInventories,
-  sortWorkstreamInventories,
-  workstreamsRoot,
-};

package/get-shit-done/bin/lib/workstream.cjs

@@ -1,389 +0,0 @@
-/**
- * Workstream — CRUD operations for workstream namespacing
- *
- * Workstreams enable parallel milestones by scoping ROADMAP.md, STATE.md,
- * REQUIREMENTS.md, and phases/ into .planning/workstreams/{name}/ directories.
- *
- * When no workstreams/ directory exists, GSD operates in "flat mode" with
- * everything at .planning/ — backward compatible with pre-workstream installs.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { output, error, toPosixPath, getMilestoneInfo, generateSlugInternal } = require('./core.cjs');
-const { platformWriteSync, platformEnsureDir } = require('./shell-command-projection.cjs');
-const { planningRoot, setActiveWorkstream, getActiveWorkstream } = require('./planning-workspace.cjs');
-const {
-  toWorkstreamSlug,
-  assertValidActiveWorkstreamName,
-  isValidActiveWorkstreamName,
-  INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE,
-} = require('./workstream-name-policy.cjs');
-const { formatGsdSlash, resolveRuntime } = require('./runtime-slash.cjs');
-const {
-  getOtherActiveWorkstreamInventories,
-  inspectWorkstream,
-  listWorkstreamInventories,
-} = require('./workstream-inventory.cjs');
-
-// ─── Migration ──────────────────────────────────────────────────────────────
-
-/**
- * Migrate flat .planning/ layout to workstream mode.
- * Moves per-workstream files (ROADMAP.md, STATE.md, REQUIREMENTS.md, phases/)
- * into .planning/workstreams/{name}/. Shared files (PROJECT.md, config.json,
- * milestones/, research/, codebase/, todos/) stay in place.
- */
-function migrateToWorkstreams(cwd, workstreamName) {
-  try {
-    assertValidActiveWorkstreamName(workstreamName, 'Invalid workstream name for migration');
-  } catch (err) {
-    throw new Error('Invalid workstream name for migration');
-  }
-
-  const baseDir = planningRoot(cwd);
-  const wsDir = path.join(baseDir, 'workstreams', workstreamName);
-
-  if (fs.existsSync(path.join(baseDir, 'workstreams'))) {
-    throw new Error('Already in workstream mode — .planning/workstreams/ exists');
-  }
-
-  const toMove = [
-    { name: 'ROADMAP.md', type: 'file' },
-    { name: 'STATE.md', type: 'file' },
-    { name: 'REQUIREMENTS.md', type: 'file' },
-    { name: 'phases', type: 'dir' },
-  ];
-
-  platformEnsureDir(wsDir);
-
-  const filesMoved = [];
-  try {
-    for (const item of toMove) {
-      const src = path.join(baseDir, item.name);
-      if (fs.existsSync(src)) {
-        const dest = path.join(wsDir, item.name);
-        fs.renameSync(src, dest);
-        filesMoved.push(item.name);
-      }
-    }
-  } catch (err) {
-    for (const name of filesMoved) {
-      try { fs.renameSync(path.join(wsDir, name), path.join(baseDir, name)); } catch {}
-    }
-    try { fs.rmSync(wsDir, { recursive: true }); } catch {}
-    try { fs.rmdirSync(path.join(baseDir, 'workstreams')); } catch {}
-    throw err;
-  }
-
-  return { migrated: true, workstream: workstreamName, files_moved: filesMoved };
-}
-
-// ─── CRUD Commands ──────────────────────────────────────────────────────────
-
-function cmdWorkstreamCreate(cwd, name, options, raw) {
-  if (!name) {
-    error('workstream name required. Usage: workstream create <name>');
-  }
-
-  const slug = toWorkstreamSlug(name);
-  if (!slug) {
-    error('Invalid workstream name — must contain at least one alphanumeric character');
-  }
-
-  const baseDir = planningRoot(cwd);
-  if (!fs.existsSync(baseDir)) {
-    error(`.planning/ directory not found — run ${formatGsdSlash('new-project', resolveRuntime(cwd))} first`);
-  }
-
-  const wsRoot = path.join(baseDir, 'workstreams');
-  const wsDir = path.join(wsRoot, slug);
-
-  if (fs.existsSync(wsDir) && fs.existsSync(path.join(wsDir, 'STATE.md'))) {
-    output({ created: false, error: 'already_exists', workstream: slug, path: toPosixPath(path.relative(cwd, wsDir)) }, raw);
-    return;
-  }
-
-  const isFlatMode = !fs.existsSync(wsRoot);
-  let migration = null;
-  if (isFlatMode && options.migrate !== false) {
-    const hasExistingWork = fs.existsSync(path.join(baseDir, 'ROADMAP.md')) ||
-                            fs.existsSync(path.join(baseDir, 'STATE.md')) ||
-                            fs.existsSync(path.join(baseDir, 'phases'));
-
-    if (hasExistingWork) {
-      const migrateName = options.migrateName || null;
-      let existingWsName;
-      if (migrateName) {
-        existingWsName = toWorkstreamSlug(migrateName);
-        if (!existingWsName) {
-          output({
-            created: false,
-            error: 'migration_failed',
-            message: 'Invalid migrate-name — must contain at least one alphanumeric character',
-          }, raw);
-          return;
-        }
-      } else {
-        try {
-          const milestone = getMilestoneInfo(cwd);
-          existingWsName = generateSlugInternal(milestone.name) || 'default';
-        } catch {
-          existingWsName = 'default';
-        }
-      }
-
-      try {
-        migration = migrateToWorkstreams(cwd, existingWsName);
-      } catch (e) {
-        output({ created: false, error: 'migration_failed', message: e.message }, raw);
-        return;
-      }
-    } else {
-      platformEnsureDir(wsRoot);
-    }
-  }
-
-  platformEnsureDir(wsDir);
-  platformEnsureDir(path.join(wsDir, 'phases'));
-
-  const today = new Date().toISOString().split('T')[0];
-  const stateContent = [
-    '---',
-    `workstream: ${slug}`,
-    `created: ${today}`,
-    '---',
-    '',
-    '# Project State',
-    '',
-    '## Current Position',
-    '**Status:** Not started',
-    '**Current Phase:** None',
-    `**Last Activity:** ${today}`,
-    '**Last Activity Description:** Workstream created',
-    '',
-    '## Progress',
-    '**Phases Complete:** 0',
-    '**Current Plan:** N/A',
-    '',
-    '## Session Continuity',
-    '**Stopped At:** N/A',
-    '**Resume File:** None',
-    '',
-  ].join('\n');
-
-  const statePath = path.join(wsDir, 'STATE.md');
-  if (!fs.existsSync(statePath)) {
-    platformWriteSync(statePath, stateContent);
-  }
-
-  setActiveWorkstream(cwd, slug);
-
-  const relPath = toPosixPath(path.relative(cwd, wsDir));
-  output({
-    created: true,
-    workstream: slug,
-    path: relPath,
-    state_path: relPath + '/STATE.md',
-    phases_path: relPath + '/phases',
-    migration: migration || null,
-    active: true,
-  }, raw);
-}
-
-function cmdWorkstreamList(cwd, raw) {
-  const inventory = listWorkstreamInventories(cwd);
-  if (inventory.mode === 'flat') {
-    output({ mode: 'flat', workstreams: [], message: inventory.message }, raw);
-    return;
-  }
-
-  const workstreams = inventory.workstreams.map(ws => ({
-    name: ws.name,
-    path: ws.path,
-    has_roadmap: ws.files.roadmap,
-    has_state: ws.files.state,
-    status: ws.status,
-    current_phase: ws.current_phase,
-    phase_count: ws.phase_count,
-    completed_phases: ws.completed_phases,
-  }));
-
-  output({ mode: 'workstream', workstreams, count: workstreams.length }, raw);
-}
-
-function cmdWorkstreamStatus(cwd, name, raw) {
-  if (!name) error('workstream name required. Usage: workstream status <name>');
-  try {
-    assertValidActiveWorkstreamName(name, INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
-  } catch {
-    error(INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
-  }
-
-  const wsDir = path.join(planningRoot(cwd), 'workstreams', name);
-  if (!fs.existsSync(wsDir)) {
-    output({ found: false, workstream: name }, raw);
-    return;
-  }
-
-  const inventory = inspectWorkstream(cwd, name);
-
-  output({
-    found: true,
-    workstream: name,
-    path: inventory.path,
-    files: inventory.files,
-    phases: inventory.phases,
-    phase_count: inventory.phase_count,
-    completed_phases: inventory.completed_phases,
-    status: inventory.status,
-    current_phase: inventory.current_phase,
-    last_activity: inventory.last_activity,
-  }, raw);
-}
-
-function cmdWorkstreamComplete(cwd, name, options, raw) {
-  if (!name) error('workstream name required. Usage: workstream complete <name>');
-  try {
-    assertValidActiveWorkstreamName(name, INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
-  } catch {
-    error(INVALID_ACTIVE_WORKSTREAM_NAME_MESSAGE);
-  }
-
-  const root = planningRoot(cwd);
-  const wsRoot = path.join(root, 'workstreams');
-  const wsDir = path.join(wsRoot, name);
-
-  if (!fs.existsSync(wsDir)) {
-    output({ completed: false, error: 'not_found', workstream: name }, raw);
-    return;
-  }
-
-  const active = getActiveWorkstream(cwd);
-  if (active === name) setActiveWorkstream(cwd, null);
-
-  const archiveDir = path.join(root, 'milestones');
-  const today = new Date().toISOString().split('T')[0];
-  let archivePath = path.join(archiveDir, `ws-${name}-${today}`);
-  let suffix = 1;
-  while (fs.existsSync(archivePath)) {
-    archivePath = path.join(archiveDir, `ws-${name}-${today}-${suffix++}`);
-  }
-
-  platformEnsureDir(archivePath);
-
-  const filesMoved = [];
-  try {
-    const entries = fs.readdirSync(wsDir, { withFileTypes: true });
-    for (const entry of entries) {
-      fs.renameSync(path.join(wsDir, entry.name), path.join(archivePath, entry.name));
-      filesMoved.push(entry.name);
-    }
-  } catch (err) {
-    for (const fname of filesMoved) {
-      try { fs.renameSync(path.join(archivePath, fname), path.join(wsDir, fname)); } catch {}
-    }
-    try { fs.rmSync(archivePath, { recursive: true }); } catch {}
-    if (active === name) setActiveWorkstream(cwd, name);
-    output({ completed: false, error: 'archive_failed', message: err.message, workstream: name }, raw);
-    return;
-  }
-
-  try { fs.rmdirSync(wsDir); } catch {}
-
-  let remainingWs = 0;
-  try {
-    remainingWs = fs.readdirSync(wsRoot, { withFileTypes: true }).filter(e => e.isDirectory()).length;
-    if (remainingWs === 0) fs.rmdirSync(wsRoot);
-  } catch {}
-
-  output({
-    completed: true,
-    workstream: name,
-    archived_to: toPosixPath(path.relative(cwd, archivePath)),
-    remaining_workstreams: remainingWs,
-    reverted_to_flat: remainingWs === 0,
-  }, raw);
-}
-
-// ─── Active Workstream Commands ──────────────────────────────────────────────
-
-function cmdWorkstreamSet(cwd, name, raw) {
-  if (!name || name === '--clear') {
-    if (name !== '--clear') {
-      error('Workstream name required. Usage: workstream set <name> (or workstream set --clear to unset)');
-    }
-    const previous = getActiveWorkstream(cwd);
-    setActiveWorkstream(cwd, null);
-    output({ active: null, cleared: true, previous: previous || null }, raw);
-    return;
-  }
-
-  if (!isValidActiveWorkstreamName(name)) {
-    output({ active: null, error: 'invalid_name', message: 'Workstream name must be alphanumeric, hyphens, underscores, or dots' }, raw);
-    return;
-  }
-
-  const wsDir = path.join(planningRoot(cwd), 'workstreams', name);
-  if (!fs.existsSync(wsDir)) {
-    output({ active: null, error: 'not_found', workstream: name }, raw);
-    return;
-  }
-
-  setActiveWorkstream(cwd, name);
-  output({ active: name, set: true }, raw, name);
-}
-
-function cmdWorkstreamGet(cwd, raw) {
-  const active = getActiveWorkstream(cwd);
-  const wsRoot = path.join(planningRoot(cwd), 'workstreams');
-  output({ active, mode: fs.existsSync(wsRoot) ? 'workstream' : 'flat' }, raw, active || 'none');
-}
-
-function cmdWorkstreamProgress(cwd, raw) {
-  const inventory = listWorkstreamInventories(cwd);
-  if (inventory.mode === 'flat') {
-    output({ mode: 'flat', workstreams: [], message: inventory.message }, raw);
-    return;
-  }
-
-  const workstreams = inventory.workstreams.map(ws => ({
-    name: ws.name,
-    active: ws.active,
-    status: ws.status,
-    current_phase: ws.current_phase,
-    phases: `${ws.completed_phases}/${ws.roadmap_phase_count}`,
-    plans: `${ws.completed_plans}/${ws.total_plans}`,
-    progress_percent: ws.progress_percent,
-  }));
-
-  output({ mode: 'workstream', active: inventory.active, workstreams, count: workstreams.length }, raw);
-}
-
-// ─── Collision Detection ────────────────────────────────────────────────────
-
-/**
- * Return other workstreams that are NOT complete.
- * Used to detect whether the milestone has active parallel work
- * when a workstream finishes its last phase.
- */
-function getOtherActiveWorkstreams(cwd, excludeWs) {
-  return getOtherActiveWorkstreamInventories(cwd, excludeWs).map(ws => ({
-    name: ws.name,
-    status: ws.status,
-    current_phase: ws.current_phase,
-    phases: `${ws.completed_phases}/${ws.phase_count}`,
-  }));
-}
-
-module.exports = {
-  migrateToWorkstreams,
-  cmdWorkstreamCreate,
-  cmdWorkstreamList,
-  cmdWorkstreamStatus,
-  cmdWorkstreamComplete,
-  cmdWorkstreamSet,
-  cmdWorkstreamGet,
-  cmdWorkstreamProgress,
-  getOtherActiveWorkstreams,
-};