@karthikrajkumar.kannan/get-things-done 1.0.0

package/lib/diff-engine.cjs

@@ -0,0 +1,245 @@
+/**
+ * GTD Diff Engine — Change detection, impact mapping, section-level targeting.
+ *
+ * Maps code changes to affected document sections for incremental updates.
+ *
+ * @module lib/diff-engine
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { fileExists } = require('./file-ops.cjs');
+
+/**
+ * File change → affected analysis dimension mapping.
+ * Pattern keys are matched against changed file paths.
+ */
+const IMPACT_MAP = [
+  { pattern: /src\/.*\.(ts|js|py|go|rs|java|rb)$/, dimensions: ['architecture', 'data-flow', 'performance'] },
+  { pattern: /route|controller|handler|endpoint/i, dimensions: ['api'] },
+  { pattern: /model|entity|schema/i, dimensions: ['data-flow', 'architecture'] },
+  { pattern: /auth|security|permission|guard/i, dimensions: ['security'] },
+  { pattern: /middleware|interceptor/i, dimensions: ['security', 'data-flow'] },
+  { pattern: /test|spec|__tests__/i, dimensions: ['architecture'] },
+  { pattern: /package\.json|go\.mod|Cargo\.toml|requirements\.txt|pyproject\.toml/, dimensions: ['dependencies'] },
+  { pattern: /Dockerfile|docker-compose|compose\./i, dimensions: ['architecture', 'performance'] },
+  { pattern: /k8s|kubernetes|helm|chart/i, dimensions: ['architecture', 'performance'] },
+  { pattern: /\.tf$|terraform/i, dimensions: ['architecture'] },
+  { pattern: /\.github\/workflows|\.gitlab-ci|Jenkinsfile/i, dimensions: ['architecture'] },
+  { pattern: /prisma|migration|\.sql$/i, dimensions: ['data-flow', 'dependencies'] },
+  { pattern: /\.env|config\./i, dimensions: ['security'] },
+];
+
+/**
+ * Analysis dimension → document section mapping.
+ */
+const DIMENSION_TO_SECTION = {
+  tdd: {
+    architecture: ['architecture-overview', 'component-design', 'deployment'],
+    api: ['api-design'],
+    'data-flow': ['data-model', 'component-design'],
+    dependencies: ['dependencies', 'deployment'],
+    security: ['security-design'],
+    performance: ['performance'],
+  },
+  hld: {
+    architecture: ['architecture', 'subsystems', 'deployment'],
+    api: ['integration-points'],
+    'data-flow': ['data-flow', 'subsystems'],
+    dependencies: ['deployment', 'cross-cutting'],
+    security: ['cross-cutting'],
+    performance: ['cross-cutting'],
+  },
+  lld: {
+    architecture: ['module-overview', 'module-specs'],
+    api: ['api-specs', 'endpoint-details'],
+    'data-flow': ['data-structures', 'query-patterns'],
+    dependencies: ['dependency-graph', 'configuration'],
+    security: ['error-handling'],
+    performance: ['algorithms'],
+  },
+  'api-docs': {
+    api: ['*'], // Full regeneration for API docs
+    security: ['authentication'],
+  },
+  'system-design': {
+    architecture: ['architecture', 'components', 'deployment'],
+    api: ['api-design'],
+    'data-flow': ['data-architecture', 'pipeline'],
+    dependencies: ['deployment'],
+    security: ['security'],
+    performance: ['reliability', 'observability'],
+  },
+  capacity: {
+    dependencies: ['resource-requirements', 'infrastructure'],
+    performance: ['performance', 'scaling', 'bottlenecks'],
+    architecture: ['system-profile'],
+  },
+  runbook: {
+    architecture: ['service-overview', 'deployment'],
+    security: ['access', 'incident-response'],
+    dependencies: ['configuration', 'troubleshooting'],
+  },
+};
+
+/**
+ * Classify a changed file by type.
+ * @param {string} filePath - Relative file path
+ * @returns {string} File type: source, config, infra, test, docs, other
+ */
+function classifyFile(filePath) {
+  if (/test|spec|__tests__/i.test(filePath)) return 'test';
+  if (/\.md$/i.test(filePath)) return 'docs';
+  if (/Dockerfile|docker-compose|\.tf$|k8s|helm|\.github/i.test(filePath)) return 'infra';
+  if (/package\.json|go\.mod|Cargo\.toml|\.env|config\./i.test(filePath)) return 'config';
+  if (/\.(ts|js|py|go|rs|java|rb|cs|php|swift)$/i.test(filePath)) return 'source';
+  return 'other';
+}
+
+/**
+ * Map changed files to affected analysis dimensions.
+ * @param {string[]} changedFiles - List of changed file paths
+ * @returns {string[]} Unique affected dimension names
+ */
+function mapToDimensions(changedFiles) {
+  const dimensions = new Set();
+  for (const file of changedFiles) {
+    for (const rule of IMPACT_MAP) {
+      if (rule.pattern.test(file)) {
+        for (const dim of rule.dimensions) dimensions.add(dim);
+      }
+    }
+  }
+  return Array.from(dimensions);
+}
+
+/**
+ * Map affected dimensions to document sections.
+ * @param {string[]} dimensions - Affected dimensions
+ * @param {string} docType - Document type
+ * @returns {string[]} Affected section names
+ */
+function mapToSections(dimensions, docType) {
+  const mapping = DIMENSION_TO_SECTION[docType];
+  if (!mapping) return ['*']; // Unknown doc type → regenerate all
+
+  const sections = new Set();
+  for (const dim of dimensions) {
+    const secs = mapping[dim] || [];
+    for (const s of secs) sections.add(s);
+  }
+  return Array.from(sections);
+}
+
+/**
+ * Generate a full impact report for changed files.
+ * @param {string[]} changedFiles - List of changed file paths
+ * @returns {{ changedFiles: number, classification: object, dimensions: string[], documents: Array }}
+ */
+function generateImpactReport(changedFiles) {
+  // Classify changes
+  const classification = { source: 0, config: 0, infra: 0, test: 0, docs: 0, other: 0 };
+  for (const file of changedFiles) {
+    const type = classifyFile(file);
+    classification[type]++;
+  }
+
+  // Map to dimensions
+  const dimensions = mapToDimensions(changedFiles);
+
+  // Map to document sections
+  const docTypes = Object.keys(DIMENSION_TO_SECTION);
+  const documents = docTypes.map((docType) => {
+    const sections = mapToSections(dimensions, docType);
+    const impact = sections.includes('*') ? 'critical' : sections.length > 3 ? 'high' : sections.length > 0 ? 'medium' : 'none';
+    return { type: docType, sections, impact };
+  }).filter((d) => d.impact !== 'none');
+
+  return {
+    changedFiles: changedFiles.length,
+    classification,
+    dimensions,
+    documents,
+  };
+}
+
+/**
+ * Extract section boundaries from a Markdown document.
+ * @param {string} content - Markdown content
+ * @returns {Array<{header: string, level: number, start: number, end: number}>}
+ */
+function extractSections(content) {
+  const lines = content.split('\n');
+  const sections = [];
+  let currentSection = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(/^(#{1,3})\s+(.+)/);
+    if (match) {
+      if (currentSection) currentSection.end = i - 1;
+      currentSection = {
+        header: match[2].trim(),
+        level: match[1].length,
+        start: i,
+        end: lines.length - 1,
+      };
+      sections.push(currentSection);
+    }
+  }
+
+  return sections;
+}
+
+/**
+ * Replace a section in a document with new content.
+ * @param {string} content - Full document content
+ * @param {string} sectionHeader - Header text to find
+ * @param {string} newSectionContent - New content for the section
+ * @returns {string} Updated document
+ */
+function replaceSection(content, sectionHeader, newSectionContent) {
+  const sections = extractSections(content);
+  const target = sections.find((s) =>
+    s.header.toLowerCase().includes(sectionHeader.toLowerCase()),
+  );
+
+  if (!target) return content; // Section not found — return unchanged
+
+  const lines = content.split('\n');
+  const nextSection = sections.find((s) => s.start > target.start && s.level <= target.level);
+  const endLine = nextSection ? nextSection.start - 1 : lines.length;
+
+  const before = lines.slice(0, target.start);
+  const after = lines.slice(endLine);
+  return [...before, newSectionContent, ...after].join('\n');
+}
+
+// CLI handler
+function run(args) {
+  const subcommand = args[0] || 'help';
+
+  if (subcommand === 'classify' && args[1]) {
+    process.stdout.write(JSON.stringify(classifyFile(args[1])));
+  } else if (subcommand === 'impact') {
+    // Read file list from stdin or args
+    const files = args.slice(1);
+    process.stdout.write(JSON.stringify(generateImpactReport(files), null, 2));
+  } else {
+    process.stderr.write('Usage: gtd-tools.cjs diff-engine <classify|impact> [files...]\n');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  IMPACT_MAP,
+  DIMENSION_TO_SECTION,
+  classifyFile,
+  mapToDimensions,
+  mapToSections,
+  generateImpactReport,
+  extractSections,
+  replaceSection,
+  run,
+};

package/lib/docs.cjs

@@ -0,0 +1,243 @@
+/**
+ * GTD Document Management — List, status, version, finalize documents.
+ *
+ * Manages the document lifecycle: draft → review → finalized
+ * Tracks versions in history/ directory.
+ *
+ * @module lib/docs
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { atomicWrite, ensureDir, fileExists } = require('./file-ops.cjs');
+const { parseFrontmatter } = require('./frontmatter.cjs');
+const { updateDocumentStatus } = require('./state.cjs');
+
+/**
+ * All recognized document types.
+ */
+const DOCUMENT_TYPES = [
+  'tdd',
+  'hld',
+  'lld',
+  'capacity',
+  'system-design',
+  'api-docs',
+  'runbook',
+];
+
+/**
+ * Mapping of document type to output filename.
+ */
+const DOC_FILENAMES = {
+  tdd: 'TDD',
+  hld: 'HLD',
+  lld: 'LLD',
+  capacity: 'CAPACITY-PLAN',
+  'system-design': 'SYSTEM-DESIGN',
+  'api-docs': 'API-DOCS',
+  runbook: 'RUNBOOK',
+};
+
+/**
+ * Get the file path for a document.
+ *
+ * @param {string} docsRoot - .planning/ directory
+ * @param {string} docType - Document type
+ * @param {boolean} [draft=false] - If true, return draft path
+ * @returns {string} Absolute file path
+ */
+function getDocumentPath(docsRoot, docType, draft = false) {
+  const filename = DOC_FILENAMES[docType] || docType.toUpperCase();
+  if (draft) {
+    return path.join(docsRoot, 'drafts', `${filename}-DRAFT.md`);
+  }
+  return path.join(docsRoot, 'documents', `${filename}.md`);
+}
+
+/**
+ * List all documents with their current status.
+ *
+ * @param {string} docsRoot - .planning/ directory
+ * @returns {Array<{type: string, status: string, version: string|null, path: string|null, draftPath: string|null}>}
+ */
+function listDocuments(docsRoot) {
+  return DOCUMENT_TYPES.map((type) => {
+    const finalPath = getDocumentPath(docsRoot, type, false);
+    const draftPath = getDocumentPath(docsRoot, type, true);
+    const hasFinal = fileExists(finalPath);
+    const hasDraft = fileExists(draftPath);
+
+    let status = 'pending';
+    let version = null;
+    let commit = null;
+
+    if (hasFinal) {
+      const content = fs.readFileSync(finalPath, 'utf8');
+      const { frontmatter } = parseFrontmatter(content);
+      version = frontmatter.version || '1.0';
+      commit = frontmatter.commit || null;
+      status = 'finalized';
+    } else if (hasDraft) {
+      status = 'drafting';
+    }
+
+    return {
+      type,
+      status,
+      version,
+      commit,
+      finalPath: hasFinal ? finalPath : null,
+      draftPath: hasDraft ? draftPath : null,
+      filename: DOC_FILENAMES[type],
+    };
+  });
+}
+
+/**
+ * Move a draft document to its final location.
+ *
+ * @param {string} docsRoot - .planning/ directory
+ * @param {string} docType - Document type
+ * @returns {{ success: boolean, finalPath: string }}
+ */
+function finalize(docsRoot, docType) {
+  const draftPath = getDocumentPath(docsRoot, docType, true);
+  const finalPath = getDocumentPath(docsRoot, docType, false);
+
+  if (!fileExists(draftPath)) {
+    throw new Error(`No draft found for ${docType} at ${draftPath}`);
+  }
+
+  ensureDir(path.dirname(finalPath));
+  const content = fs.readFileSync(draftPath, 'utf8');
+  atomicWrite(finalPath, content);
+
+  // Remove draft
+  try {
+    fs.unlinkSync(draftPath);
+  } catch (_) {}
+
+  // Update state
+  updateDocumentStatus(docsRoot, docType, {
+    status: 'finalized',
+    version: extractVersion(content) || '1.0',
+    commit: extractCommit(content),
+  });
+
+  return { success: true, finalPath };
+}
+
+/**
+ * Archive the current document version to history/ before overwriting.
+ *
+ * @param {string} docsRoot - .planning/ directory
+ * @param {string} docType - Document type
+ * @returns {{ archived: boolean, archivePath: string|null }}
+ */
+function archiveVersion(docsRoot, docType) {
+  const finalPath = getDocumentPath(docsRoot, docType, false);
+
+  if (!fileExists(finalPath)) {
+    return { archived: false, archivePath: null };
+  }
+
+  const content = fs.readFileSync(finalPath, 'utf8');
+  const { frontmatter } = parseFrontmatter(content);
+  const version = frontmatter.version || '1.0';
+  const commit = frontmatter.commit || 'unknown';
+  const date = new Date().toISOString().split('T')[0];
+
+  const historyDir = path.join(docsRoot, 'history', DOC_FILENAMES[docType] || docType.toUpperCase());
+  ensureDir(historyDir);
+
+  const archiveName = `v${version}_${commit}_${date}.md`;
+  const archivePath = path.join(historyDir, archiveName);
+  atomicWrite(archivePath, content);
+
+  return { archived: true, archivePath };
+}
+
+/**
+ * Get metadata from a document file.
+ *
+ * @param {string} docsRoot - .planning/ directory
+ * @param {string} docType - Document type
+ * @returns {object|null} Frontmatter metadata or null
+ */
+function getDocumentMetadata(docsRoot, docType) {
+  const finalPath = getDocumentPath(docsRoot, docType, false);
+  const draftPath = getDocumentPath(docsRoot, docType, true);
+
+  const filePath = fileExists(finalPath) ? finalPath : fileExists(draftPath) ? draftPath : null;
+  if (!filePath) return null;
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const { frontmatter } = parseFrontmatter(content);
+  return {
+    ...frontmatter,
+    path: filePath,
+    isDraft: filePath === draftPath,
+  };
+}
+
+/**
+ * Bump the version number of a document.
+ *
+ * @param {string} currentVersion - Current version string (e.g., "1.0")
+ * @param {'major'|'minor'} [bump='minor'] - Bump type
+ * @returns {string} New version string
+ */
+function bumpVersion(currentVersion, bump = 'minor') {
+  if (!currentVersion) return '1.0';
+  const parts = currentVersion.split('.').map(Number);
+  if (bump === 'major') {
+    return `${parts[0] + 1}.0`;
+  }
+  return `${parts[0]}.${(parts[1] || 0) + 1}`;
+}
+
+// --- Internal helpers ---
+
+function extractVersion(content) {
+  const match = content.match(/\*\*Version:\*\*\s*(\S+)/);
+  return match ? match[1] : null;
+}
+
+function extractCommit(content) {
+  const match = content.match(/\*\*Commit:\*\*\s*(\S+)/);
+  return match ? match[1] : null;
+}
+
+// CLI handler
+function run(args) {
+  const docsRoot = path.join(process.cwd(), '.planning');
+  const subcommand = args[0] || 'list';
+
+  if (subcommand === 'list') {
+    process.stdout.write(JSON.stringify(listDocuments(docsRoot), null, 2));
+  } else if (subcommand === 'status' && args[1]) {
+    const meta = getDocumentMetadata(docsRoot, args[1]);
+    process.stdout.write(JSON.stringify(meta, null, 2));
+  } else if (subcommand === 'finalize' && args[1]) {
+    const result = finalize(docsRoot, args[1]);
+    process.stdout.write(JSON.stringify(result, null, 2));
+  } else {
+    process.stderr.write('Usage: gtd-tools.cjs doc <list|status|finalize> [type]\n');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  DOCUMENT_TYPES,
+  DOC_FILENAMES,
+  getDocumentPath,
+  listDocuments,
+  finalize,
+  archiveVersion,
+  getDocumentMetadata,
+  bumpVersion,
+  run,
+};

package/lib/drift-engine.cjs

@@ -0,0 +1,202 @@
+/**
+ * GTD Drift Engine — Spec-code drift detection, categorization, reconciliation planning.
+ *
+ * Drift = difference between what specs/docs SAY and what code DOES.
+ * This is GTD's killer differentiator — no other framework detects this.
+ *
+ * @module lib/drift-engine
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { fileExists } = require('./file-ops.cjs');
+const { parseFrontmatter } = require('./frontmatter.cjs');
+
+/**
+ * Drift categories.
+ */
+const DRIFT_CATEGORIES = {
+  ADDITION: 'Code has something that specs/docs do not mention',
+  REMOVAL: 'Specs/docs mention something that code does not have',
+  MUTATION: 'Both exist but behavior or structure differs',
+  STRUCTURAL: 'Architecture changed (new service, removed layer, different pattern)',
+};
+
+/**
+ * Drift severity levels.
+ */
+const SEVERITY = {
+  CRITICAL: 'Fundamental architectural change or security implication',
+  MAJOR: 'Significant feature or behavior difference',
+  MINOR: 'Small discrepancy, cosmetic or naming difference',
+  INFO: 'Informational — code improved beyond spec',
+};
+
+/**
+ * Check if drift detection is needed.
+ * @param {string} docsRoot - .planning/ directory
+ * @returns {{ needed: boolean, reason: string, lastCheck: string|null }}
+ */
+function isDriftCheckNeeded(docsRoot) {
+  const statePath = path.join(docsRoot, 'STATE.md');
+  if (!fileExists(statePath)) {
+    return { needed: false, reason: 'No state file — nothing to compare' };
+  }
+
+  const content = fs.readFileSync(statePath, 'utf8');
+  const { frontmatter } = parseFrontmatter(content);
+
+  const lastDriftCheck = frontmatter.sync_last_drift_check || null;
+  const lastScanCommit = frontmatter.backward_last_scan_commit || null;
+  const forwardStatus = frontmatter.forward_status || 'empty';
+
+  if (forwardStatus === 'empty' && !lastScanCommit) {
+    return { needed: false, reason: 'No forward or backward state — nothing to compare' };
+  }
+
+  if (!lastDriftCheck) {
+    return { needed: true, reason: 'Drift check has never been run', lastCheck: null };
+  }
+
+  try {
+    const { getGitCommit } = require('./git.cjs');
+    const currentCommit = getGitCommit(path.dirname(docsRoot));
+    if (currentCommit && frontmatter.sync_last_drift_commit !== currentCommit) {
+      return { needed: true, reason: 'Code changed since last drift check', lastCheck: lastDriftCheck };
+    }
+  } catch (_) {}
+
+  return { needed: false, reason: 'Drift check is current', lastCheck: lastDriftCheck };
+}
+
+/**
+ * Build context for the drift-detector agent.
+ * @param {string} docsRoot - .planning/ directory
+ * @returns {object} Context for drift detection
+ */
+function buildDriftContext(docsRoot) {
+  const context = { hasSpecs: false, hasDocs: false, hasCode: false, specs: {}, docs: {} };
+
+  // Forward specs
+  for (const [key, file] of [['requirements', 'REQUIREMENTS.md'], ['roadmap', 'ROADMAP.md'], ['project', 'PROJECT.md']]) {
+    if (fileExists(path.join(docsRoot, file))) {
+      context.hasSpecs = true;
+      context.specs[key] = path.join(docsRoot, file);
+    }
+  }
+
+  // Backward docs
+  const docsDir = path.join(docsRoot, 'documents');
+  if (fs.existsSync(docsDir)) {
+    const docFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith('.md'));
+    if (docFiles.length > 0) {
+      context.hasDocs = true;
+      for (const f of docFiles) {
+        context.docs[f.replace('.md', '').toLowerCase()] = path.join(docsDir, f);
+      }
+    }
+  }
+
+  if (fileExists(path.join(docsRoot, 'CODEBASE-MAP.md'))) context.hasCode = true;
+  return context;
+}
+
+/**
+ * Parse a DRIFT-REPORT.md file.
+ * @param {string} docsRoot - .planning/ directory
+ * @returns {{ exists: boolean, items: Array, summary: object }}
+ */
+function parseDriftReport(docsRoot) {
+  const reportPath = path.join(docsRoot, 'DRIFT-REPORT.md');
+  if (!fileExists(reportPath)) {
+    return { exists: false, items: [], summary: { total: 0, critical: 0, major: 0, minor: 0, info: 0 } };
+  }
+
+  const content = fs.readFileSync(reportPath, 'utf8');
+  const { frontmatter } = parseFrontmatter(content);
+
+  return {
+    exists: true,
+    items: frontmatter.drift_items ? JSON.parse(frontmatter.drift_items) : [],
+    summary: {
+      total: frontmatter.total_items || 0,
+      critical: frontmatter.critical || 0,
+      major: frontmatter.major || 0,
+      minor: frontmatter.minor || 0,
+      info: frontmatter.info || 0,
+    },
+    timestamp: frontmatter.timestamp || null,
+  };
+}
+
+/**
+ * Reconciliation strategies.
+ */
+const RECONCILIATION_STRATEGIES = {
+  'code-wins': 'Update specs and docs to match current code (most common)',
+  'spec-wins': 'Generate tasks to update code to match spec',
+  interactive: 'Present each drift item to user for individual decision',
+};
+
+/**
+ * Get reconciliation actions for a drift category.
+ * @param {string} category - ADDITION, REMOVAL, MUTATION, STRUCTURAL
+ * @returns {Array<{action: string, description: string}>}
+ */
+function getReconciliationActions(category) {
+  const ACTIONS = {
+    ADDITION: [
+      { action: 'add-to-spec', description: 'Add to REQUIREMENTS.md and update ROADMAP.md' },
+      { action: 'remove-code', description: 'Create task to remove the undocumented code' },
+      { action: 'ignore', description: 'Acknowledge and mark as intentional' },
+    ],
+    REMOVAL: [
+      { action: 'implement', description: 'Create task to implement the missing feature' },
+      { action: 'remove-from-spec', description: 'Remove from REQUIREMENTS.md (descoped)' },
+      { action: 'defer', description: 'Move to v2/future scope' },
+    ],
+    MUTATION: [
+      { action: 'update-spec', description: 'Update spec to match code behavior' },
+      { action: 'update-code', description: 'Create task to fix code to match spec' },
+      { action: 'document', description: 'Document the difference as intentional deviation' },
+    ],
+    STRUCTURAL: [
+      { action: 'update-all', description: 'Update all specs, docs, and diagrams' },
+      { action: 'revert', description: 'Create task to revert architectural change' },
+      { action: 'accept', description: 'Accept new architecture, update everything' },
+    ],
+  };
+  return ACTIONS[category] || [{ action: 'ignore', description: 'No action needed' }];
+}
+
+// CLI handler
+function run(args) {
+  const docsRoot = path.join(process.cwd(), '.planning');
+  const subcommand = args[0] || 'check';
+
+  if (subcommand === 'check') {
+    process.stdout.write(JSON.stringify(isDriftCheckNeeded(docsRoot), null, 2));
+  } else if (subcommand === 'context') {
+    process.stdout.write(JSON.stringify(buildDriftContext(docsRoot), null, 2));
+  } else if (subcommand === 'report') {
+    process.stdout.write(JSON.stringify(parseDriftReport(docsRoot), null, 2));
+  } else if (subcommand === 'actions' && args[1]) {
+    process.stdout.write(JSON.stringify(getReconciliationActions(args[1]), null, 2));
+  } else {
+    process.stderr.write('Usage: gtd-tools.cjs drift <check|context|report|actions> [category]\n');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  DRIFT_CATEGORIES,
+  SEVERITY,
+  RECONCILIATION_STRATEGIES,
+  isDriftCheckNeeded,
+  buildDriftContext,
+  parseDriftReport,
+  getReconciliationActions,
+  run,
+};