@ai-is-gonna/get-tasks-done 0.2.0

package/get-tasks-done/bin/lib/state-command-router.cjs

@@ -0,0 +1,318 @@
+'use strict';
+
+const { STATE_SUBCOMMANDS } = require('./command-aliases.generated.cjs');
+const { routeCjsCommandFamily } = require('./cjs-command-router-adapter.cjs');
+const { output } = require('./core.cjs');
+
+// ─── SDK bridge (Phase 5.1) ─────────────────────────────────────────────────
+// executeForCjs is loaded lazily from the SDK public package export so this
+// router does not rely on private dist subpaths that are not exported.
+let _executeForCjs = null;
+let _formatStateLoadRawStdout = null;
+
+function tryLoadSdk() {
+  if (_executeForCjs !== null) return true;
+  try {
+    const sdkModule = require('@ai-is-gonna/gtd-sdk');
+    _executeForCjs = sdkModule.executeForCjs;
+    _formatStateLoadRawStdout = sdkModule.formatStateLoadRawStdout;
+    if (typeof _executeForCjs !== 'function' || typeof _formatStateLoadRawStdout !== 'function') {
+      _executeForCjs = null;
+      _formatStateLoadRawStdout = null;
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Dispatch a subcommand via the SDK sync bridge.
+ *
+ * Returns true if dispatched successfully, false if the SDK is unavailable.
+ * The caller must still handle result.ok=false as a hard error.
+ *
+ * @param {string} registryCommand - Registry command name (e.g. 'state.json')
+ * @param {string[]} registryArgs - Args for the registry handler
+ * @param {string} cwd - Project directory
+ * @param {boolean} raw - Raw output mode
+ * @param {Function} error - Error reporter
+ * @param {Function} [rawFormatter] - Optional raw output formatter (for state.load)
+ * @returns {boolean} true if handled, false to fall through to CJS
+ */
+function dispatchViaSdk(registryCommand, registryArgs, legacyArgs, cwd, raw, error, rawFormatter) {
+  if (!tryLoadSdk()) return false;
+
+  const result = _executeForCjs({
+    registryCommand,
+    registryArgs,
+    legacyCommand: 'state',
+    legacyArgs,
+    mode: raw ? 'raw' : 'json',
+    projectDir: cwd,
+    // workstream: not threaded here — GTDTransport forces subprocess for workstream
+    // requests and subprocess is disabled in the worker. Workstream commands fall
+    // back to the CJS path (see routeStateCommand guard below).
+  });
+
+  if (!result.ok) {
+    error(result.errorDetails && result.errorDetails.message
+      ? result.errorDetails.message
+      : `state ${registryCommand} failed (${result.errorKind})`);
+    return true; // handled (error was reported)
+  }
+
+  if (raw && rawFormatter) {
+    const rawText = rawFormatter(result.data);
+    const fs = require('fs');
+    fs.writeSync(1, rawText);
+  } else {
+    output(result.data);
+  }
+  return true;
+}
+
+/**
+ * Manifest-backed state subcommand router.
+ * Keeps gtd-tools.cjs thin while preserving existing command semantics.
+ *
+ * Phase 5.1: handlers that have SDK equivalents are dispatched via
+ * executeForCjs (the sync bridge). CJS fallback is retained for:
+ * - complete-phase: no SDK counterpart.
+ * - Any command when GTD_WORKSTREAM is active (GTDTransport forces subprocess
+ *   for workstream requests; subprocess is disabled in the sync bridge worker).
+ * - Any command when the SDK is not available (build not present).
+ */
+function routeStateCommand({ state, args, cwd, raw, parseNamedArgs, error }) {
+  const parsePlans = (plans) => {
+    const parsedPlans = plans == null ? null : Number.parseInt(plans, 10);
+    if (plans != null && Number.isNaN(parsedPlans)) {
+      error('Invalid --plans value. Expected an integer.');
+      return null;
+    }
+    return parsedPlans;
+  };
+
+  // Workstream guard: if GTD_WORKSTREAM is set, the sync bridge worker cannot
+  // handle the request (GTDTransport.subprocessReason returns 'workstream_forced'
+  // and subprocess is disabled in the worker). Fall back to CJS path for all
+  // workstream-scoped state commands.
+  const activeWorkstream = process.env.GTD_WORKSTREAM;
+  const sdkAvailable = !activeWorkstream && tryLoadSdk();
+
+  // Helper: build SDK-backed handler that falls through to CJS on SDK failure.
+  // cjsFallback is called when SDK is unavailable or when the subcommand has no
+  // SDK counterpart.
+  function sdkHandler(registryCommand, registryArgs, legacyArgs, rawFormatter, cjsFallback) {
+    if (!sdkAvailable) return cjsFallback;
+    return () => {
+      const handled = dispatchViaSdk(
+        registryCommand, registryArgs, legacyArgs, cwd, raw, error, rawFormatter,
+      );
+      if (!handled) cjsFallback();
+    };
+  }
+
+  routeCjsCommandFamily({
+    args,
+    subcommands: ['load', 'complete-phase', ...STATE_SUBCOMMANDS.filter((s) => s !== 'load')],
+    defaultSubcommand: 'load',
+    unsupported: {
+      'add-roadmap-evolution': 'state add-roadmap-evolution is SDK-only. Use: gtd-sdk query state.add-roadmap-evolution ...',
+    },
+    error,
+    unknownMessage: (subcommand, available) => `Unknown state subcommand: "${subcommand}". Available: ${available.join(', ')}`,
+    handlers: {
+      load: sdkHandler(
+        'state.load',
+        [],
+        args.slice(1),
+        _formatStateLoadRawStdout,
+        () => state.cmdStateLoad(cwd, raw),
+      ),
+      json: sdkHandler(
+        'state.json',
+        [],
+        args.slice(1),
+        null,
+        () => state.cmdStateJson(cwd, raw),
+      ),
+      get: sdkHandler(
+        'state.get',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => state.cmdStateGet(cwd, args[2], raw),
+      ),
+      update: sdkHandler(
+        'state.update',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => state.cmdStateUpdate(cwd, args[2], args[3]),
+      ),
+      patch: sdkHandler(
+        'state.patch',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const patches = {};
+          for (let i = 2; i < args.length; i += 2) {
+            const key = args[i].replace(/^--/, '');
+            const value = args[i + 1];
+            if (key && value !== undefined) {
+              patches[key] = value;
+            }
+          }
+          state.cmdStatePatch(cwd, patches, raw);
+        },
+      ),
+      'advance-plan': sdkHandler(
+        'state.advance-plan',
+        [],
+        args.slice(1),
+        null,
+        () => state.cmdStateAdvancePlan(cwd, raw),
+      ),
+      'record-metric': sdkHandler(
+        'state.record-metric',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { phase: p, plan, duration, tasks, files } = parseNamedArgs(args, ['phase', 'plan', 'duration', 'tasks', 'files']);
+          state.cmdStateRecordMetric(cwd, { phase: p, plan, duration, tasks, files }, raw);
+        },
+      ),
+      'update-progress': sdkHandler(
+        'state.update-progress',
+        [],
+        args.slice(1),
+        null,
+        () => state.cmdStateUpdateProgress(cwd, raw),
+      ),
+      'add-decision': sdkHandler(
+        'state.add-decision',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { phase: p, summary, 'summary-file': summary_file, rationale, 'rationale-file': rationale_file } = parseNamedArgs(args, ['phase', 'summary', 'summary-file', 'rationale', 'rationale-file']);
+          state.cmdStateAddDecision(cwd, { phase: p, summary, summary_file, rationale: rationale || '', rationale_file }, raw);
+        },
+      ),
+      'add-blocker': sdkHandler(
+        'state.add-blocker',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { text, 'text-file': text_file } = parseNamedArgs(args, ['text', 'text-file']);
+          state.cmdStateAddBlocker(cwd, { text, text_file }, raw);
+        },
+      ),
+      'resolve-blocker': sdkHandler(
+        'state.resolve-blocker',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => state.cmdStateResolveBlocker(cwd, parseNamedArgs(args, ['text']).text, raw),
+      ),
+      'record-session': sdkHandler(
+        'state.record-session',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { 'stopped-at': stopped_at, 'resume-file': resume_file } = parseNamedArgs(args, ['stopped-at', 'resume-file']);
+          state.cmdStateRecordSession(cwd, { stopped_at, resume_file: resume_file || 'None' }, raw);
+        },
+      ),
+      'begin-phase': sdkHandler(
+        'state.begin-phase',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { phase: p, name, plans } = parseNamedArgs(args, ['phase', 'name', 'plans']);
+          state.cmdStateBeginPhase(cwd, p, name, parsePlans(plans), raw);
+        },
+      ),
+      'signal-waiting': sdkHandler(
+        'state.signal-waiting',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { type, question, options, phase: p } = parseNamedArgs(args, ['type', 'question', 'options', 'phase']);
+          state.cmdSignalWaiting(cwd, type, question, options, p, raw);
+        },
+      ),
+      'signal-resume': sdkHandler(
+        'state.signal-resume',
+        [],
+        args.slice(1),
+        null,
+        () => state.cmdSignalResume(cwd, raw),
+      ),
+      'planned-phase': sdkHandler(
+        'state.planned-phase',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { phase: p, plans } = parseNamedArgs(args, ['phase', 'name', 'plans']);
+          state.cmdStatePlannedPhase(cwd, p, parsePlans(plans), raw);
+        },
+      ),
+      validate: sdkHandler(
+        'state.validate',
+        [],
+        args.slice(1),
+        null,
+        () => state.cmdStateValidate(cwd, raw),
+      ),
+      sync: sdkHandler(
+        'state.sync',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { verify } = parseNamedArgs(args, [], ['verify']);
+          state.cmdStateSync(cwd, { verify }, raw);
+        },
+      ),
+      prune: sdkHandler(
+        'state.prune',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { 'keep-recent': keepRecent, 'dry-run': dryRun } = parseNamedArgs(args, ['keep-recent'], ['dry-run']);
+          state.cmdStatePrune(cwd, { keepRecent: keepRecent || '3', dryRun: !!dryRun }, raw);
+        },
+      ),
+      // complete-phase: CJS-only — no SDK counterpart.
+      'complete-phase': () => {
+        const { phase: p } = parseNamedArgs(args, ['phase']);
+        state.cmdStateCompletePhase(cwd, raw, p || args[2]);
+      },
+      'milestone-switch': sdkHandler(
+        'state.milestone-switch',
+        args.slice(2),
+        args.slice(1),
+        null,
+        () => {
+          const { milestone, name } = parseNamedArgs(args, ['milestone', 'name']);
+          state.cmdStateMilestoneSwitch(cwd, milestone, name, raw);
+        },
+      ),
+    },
+  });
+}
+
+module.exports = {
+  routeStateCommand,
+};

package/get-tasks-done/bin/lib/state-document.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * STATE.md Document Module — CJS adapter.
+ *
+ * The implementation is generated from sdk/src/query/state-document.ts and
+ * lives in state-document.generated.cjs. This file is a thin re-export so
+ * that existing call sites (state.cjs, workstream-inventory.cjs, init.cjs,
+ * and tests) can continue to require('./state-document') unchanged.
+ */
+
+module.exports = require('./state-document.generated.cjs');

package/get-tasks-done/bin/lib/state-document.generated.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Source: sdk/src/query/state-document.ts
+ * Regenerate: cd sdk && npm run gen:state-document
+ *
+ * STATE.md Document Module — pure transforms for STATE.md text.
+ * This module does not read the filesystem and does not own persistence or locking.
+ */
+
+// Internal helpers
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function toFiniteNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+}
+
+function existingProgressExceedsDerived(existingProgress, derivedProgress, key) {
+    const existing = toFiniteNumber(existingProgress[key]);
+    const derived = toFiniteNumber(derivedProgress[key]);
+    return existing !== null && derived !== null && existing > derived;
+}
+
+function stateExtractField(content, fieldName) {
+    const escaped = escapeRegex(fieldName);
+    const boldPattern = new RegExp(`\\*\\*${escaped}:\\*\\*[ \\t]*(.+)`, 'i');
+    const boldMatch = content.match(boldPattern);
+    if (boldMatch)
+        return boldMatch[1].trim();
+    const plainPattern = new RegExp(`^${escaped}:[ \\t]*(.+)`, 'im');
+    const plainMatch = content.match(plainPattern);
+    return plainMatch ? plainMatch[1].trim() : null;
+}
+
+function stateReplaceField(content, fieldName, newValue) {
+    const escaped = escapeRegex(fieldName);
+    const boldPattern = new RegExp(`(\\*\\*${escaped}:\\*\\*\\s*)(.*)`, 'i');
+    if (boldPattern.test(content)) {
+        return content.replace(boldPattern, (_match, prefix) => `${prefix}${newValue}`);
+    }
+    const plainPattern = new RegExp(`(^${escaped}:\\s*)(.*)`, 'im');
+    if (plainPattern.test(content)) {
+        return content.replace(plainPattern, (_match, prefix) => `${prefix}${newValue}`);
+    }
+    return null;
+}
+
+function stateReplaceFieldWithFallback(content, primary, fallback, value) {
+    let result = stateReplaceField(content, primary, value);
+    if (result)
+        return result;
+    if (fallback) {
+        result = stateReplaceField(content, fallback, value);
+        if (result)
+            return result;
+    }
+    return content;
+}
+
+function normalizeStateStatus(status, pausedAt) {
+    let normalizedStatus = status || 'unknown';
+    const statusLower = (status || '').toLowerCase();
+    if (statusLower.includes('paused') || statusLower.includes('stopped') || pausedAt) {
+        normalizedStatus = 'paused';
+    }
+    else if (statusLower.includes('executing') || statusLower.includes('in progress')) {
+        normalizedStatus = 'executing';
+    }
+    else if (statusLower.includes('planning') || statusLower.includes('ready to plan')) {
+        normalizedStatus = 'planning';
+    }
+    else if (statusLower.includes('discussing')) {
+        normalizedStatus = 'discussing';
+    }
+    else if (statusLower.includes('verif')) {
+        normalizedStatus = 'verifying';
+    }
+    else if (statusLower.includes('complete') || statusLower.includes('done')) {
+        normalizedStatus = 'completed';
+    }
+    else if (statusLower.includes('ready to execute')) {
+        normalizedStatus = 'executing';
+    }
+    return normalizedStatus;
+}
+
+function computeProgressPercent(completedPlans, totalPlans, completedPhases, totalPhases) {
+    const hasPlanData = totalPlans !== null && totalPlans > 0 && completedPlans !== null;
+    const hasPhaseData = totalPhases !== null && totalPhases > 0 && completedPhases !== null;
+    if (!hasPlanData && !hasPhaseData)
+        return null;
+    const planFraction = hasPlanData ? completedPlans / totalPlans : 1;
+    const phaseFraction = hasPhaseData ? completedPhases / totalPhases : 1;
+    return Math.min(100, Math.round(Math.min(planFraction, phaseFraction) * 100));
+}
+
+function shouldPreserveExistingProgress(existingProgress, derivedProgress) {
+    if (!existingProgress || typeof existingProgress !== 'object')
+        return false;
+    if (!derivedProgress || typeof derivedProgress !== 'object')
+        return false;
+    const existing = existingProgress;
+    const derived = derivedProgress;
+    return (existingProgressExceedsDerived(existing, derived, 'total_phases') ||
+        existingProgressExceedsDerived(existing, derived, 'completed_phases') ||
+        existingProgressExceedsDerived(existing, derived, 'total_plans') ||
+        existingProgressExceedsDerived(existing, derived, 'completed_plans'));
+}
+
+function normalizeProgressNumbers(progress) {
+    if (!progress || typeof progress !== 'object')
+        return progress;
+    const normalized = { ...progress };
+    for (const key of ['total_phases', 'completed_phases', 'total_plans', 'completed_plans', 'percent']) {
+        const number = toFiniteNumber(normalized[key]);
+        if (number !== null)
+            normalized[key] = number;
+    }
+    return normalized;
+}
+
+module.exports = { stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, normalizeStateStatus, computeProgressPercent, shouldPreserveExistingProgress, normalizeProgressNumbers };