jumpstart-mode 1.1.12 → 1.1.13

package/bin/lib/deterministic-artifacts.js

@@ -0,0 +1,151 @@
+/**
+ * deterministic-artifacts.js — Deterministic Artifact Generation Mode (Item 56)
+ *
+ * Make outputs as stable as possible for governance and repeatability.
+ *
+ * Usage:
+ *   node bin/lib/deterministic-artifacts.js normalize|verify|diff [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Normalize markdown content for deterministic comparison.
+ *
+ * @param {string} content - Markdown content.
+ * @returns {string}
+ */
+function normalizeMarkdown(content) {
+  return content
+    .replace(/\r\n/g, '\n')                    // Normalize line endings
+    .replace(/\t/g, '  ')                       // Tabs to spaces
+    .replace(/[ \t]+$/gm, '')                   // Trailing whitespace
+    .replace(/\n{3,}/g, '\n\n')                 // Max 2 consecutive newlines
+    .replace(/<!--.*?-->/gs, '')                // Remove HTML comments
+    .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}[^\s]*/g, '[TIMESTAMP]')  // Normalize timestamps
+    .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, '[UUID]')  // Normalize UUIDs
+    .trim() + '\n';
+}
+
+/**
+ * Generate a content hash for an artifact.
+ *
+ * @param {string} content
+ * @returns {string}
+ */
+function hashContent(content) {
+  const normalized = normalizeMarkdown(content);
+  return crypto.createHash('sha256').update(normalized).digest('hex').substring(0, 16);
+}
+
+/**
+ * Normalize a file for deterministic comparison.
+ *
+ * @param {string} filePath
+ * @param {object} [options]
+ * @returns {object}
+ */
+function normalizeFile(filePath, options = {}) {
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `File not found: ${filePath}` };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const normalized = normalizeMarkdown(content);
+  const hash = hashContent(content);
+
+  if (options.write) {
+    fs.writeFileSync(filePath, normalized, 'utf8');
+  }
+
+  return {
+    success: true,
+    file: filePath,
+    original_length: content.length,
+    normalized_length: normalized.length,
+    hash,
+    modified: content !== normalized
+  };
+}
+
+/**
+ * Verify artifact stability between versions.
+ *
+ * @param {string} file1
+ * @param {string} file2
+ * @returns {object}
+ */
+function verifyStability(file1, file2) {
+  if (!fs.existsSync(file1)) return { success: false, error: `File not found: ${file1}` };
+  if (!fs.existsSync(file2)) return { success: false, error: `File not found: ${file2}` };
+
+  const content1 = normalizeMarkdown(fs.readFileSync(file1, 'utf8'));
+  const content2 = normalizeMarkdown(fs.readFileSync(file2, 'utf8'));
+  const hash1 = hashContent(content1);
+  const hash2 = hashContent(content2);
+
+  const lines1 = content1.split('\n');
+  const lines2 = content2.split('\n');
+  let diffLines = 0;
+
+  const maxLines = Math.max(lines1.length, lines2.length);
+  for (let i = 0; i < maxLines; i++) {
+    if (lines1[i] !== lines2[i]) diffLines++;
+  }
+
+  const similarity = maxLines > 0 ? Math.round(((maxLines - diffLines) / maxLines) * 100) : 100;
+
+  return {
+    success: true,
+    identical: hash1 === hash2,
+    similarity,
+    hash1,
+    hash2,
+    diff_lines: diffLines,
+    total_lines: maxLines
+  };
+}
+
+/**
+ * Batch normalize all spec files.
+ *
+ * @param {string} root
+ * @param {object} [options]
+ * @returns {object}
+ */
+function normalizeSpecs(root, options = {}) {
+  const specsDir = path.join(root, 'specs');
+  if (!fs.existsSync(specsDir)) {
+    return { success: true, files: 0, message: 'No specs directory found' };
+  }
+
+  const results = [];
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) walk(path.join(dir, entry.name));
+      else if (entry.isFile() && entry.name.endsWith('.md')) {
+        results.push(normalizeFile(path.join(dir, entry.name), options));
+      }
+    }
+  }
+  walk(specsDir);
+
+  return {
+    success: true,
+    files: results.length,
+    modified: results.filter(r => r.modified).length,
+    results
+  };
+}
+
+module.exports = {
+  normalizeMarkdown,
+  hashContent,
+  normalizeFile,
+  verifyStability,
+  normalizeSpecs
+};

package/bin/lib/diagram-studio.js

@@ -0,0 +1,115 @@
+/**
+ * diagram-studio.js — Diagram Studio (Item 70)
+ *
+ * Generate, validate, compare, and refine C4, BPMN, sequence,
+ * data flow, and deployment diagrams.
+ *
+ * Usage:
+ *   node bin/lib/diagram-studio.js generate|validate|compare|list [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DIAGRAM_TYPES = ['c4-context', 'c4-container', 'c4-component', 'sequence', 'data-flow', 'deployment', 'bpmn', 'erd'];
+
+const DIAGRAM_TEMPLATES = {
+  'c4-context': '```mermaid\nC4Context\n  title System Context Diagram\n  Person(user, "User")\n  System(system, "System")\n  Rel(user, system, "Uses")\n```',
+  'c4-container': '```mermaid\nC4Container\n  title Container Diagram\n  Container(api, "API", "Node.js")\n  ContainerDb(db, "Database", "PostgreSQL")\n  Rel(api, db, "Reads/Writes")\n```',
+  'sequence': '```mermaid\nsequenceDiagram\n  participant Client\n  participant Server\n  Client->>Server: Request\n  Server-->>Client: Response\n```',
+  'data-flow': '```mermaid\nflowchart LR\n  A[Input] --> B[Process]\n  B --> C[Output]\n```',
+  'deployment': '```mermaid\nflowchart TB\n  subgraph Cloud\n    LB[Load Balancer]\n    APP[App Server]\n    DB[(Database)]\n  end\n  LB --> APP --> DB\n```'
+};
+
+/**
+ * Generate a diagram template.
+ */
+function generateDiagram(type, options = {}) {
+  if (!DIAGRAM_TYPES.includes(type)) {
+    return { success: false, error: `Unknown type: ${type}. Valid: ${DIAGRAM_TYPES.join(', ')}` };
+  }
+
+  const template = DIAGRAM_TEMPLATES[type] || `\`\`\`mermaid\nflowchart LR\n  A[${type}] --> B[TODO]\n\`\`\``;
+  
+  return {
+    success: true,
+    type,
+    content: template,
+    editable: true,
+    generated_at: new Date().toISOString()
+  };
+}
+
+/**
+ * Validate a mermaid diagram string.
+ */
+function validateDiagram(content, options = {}) {
+  if (!content) return { success: false, error: 'Diagram content is required' };
+
+  const issues = [];
+  
+  // Check for mermaid code block
+  const hasFence = content.includes('```mermaid');
+  if (!hasFence && !content.match(/^(graph|flowchart|sequenceDiagram|classDiagram|C4)/m)) {
+    issues.push({ type: 'syntax', message: 'No recognized Mermaid diagram type found' });
+  }
+
+  // Check for balanced brackets
+  const open = (content.match(/[\[{(]/g) || []).length;
+  const close = (content.match(/[\]})]/g) || []).length;
+  if (open !== close) {
+    issues.push({ type: 'syntax', message: `Unbalanced brackets: ${open} open, ${close} close` });
+  }
+
+  // Check for empty nodes
+  if (content.match(/\[\s*\]/)) {
+    issues.push({ type: 'warning', message: 'Empty node labels detected' });
+  }
+
+  return {
+    success: true,
+    valid: issues.length === 0,
+    issues,
+    diagram_type: hasFence ? 'mermaid-fenced' : 'mermaid-raw'
+  };
+}
+
+/**
+ * Compare two diagrams.
+ */
+function compareDiagrams(diagramA, diagramB, options = {}) {
+  if (!diagramA || !diagramB) return { success: false, error: 'Both diagrams are required' };
+
+  const nodesA = new Set((diagramA.match(/\w+[\[({]/g) || []).map(n => n.slice(0, -1)));
+  const nodesB = new Set((diagramB.match(/\w+[\[({]/g) || []).map(n => n.slice(0, -1)));
+
+  const added = [...nodesB].filter(n => !nodesA.has(n));
+  const removed = [...nodesA].filter(n => !nodesB.has(n));
+  const unchanged = [...nodesA].filter(n => nodesB.has(n));
+
+  return {
+    success: true,
+    added,
+    removed,
+    unchanged,
+    has_changes: added.length > 0 || removed.length > 0
+  };
+}
+
+/**
+ * List available diagram types.
+ */
+function listDiagramTypes() {
+  return {
+    success: true,
+    types: DIAGRAM_TYPES,
+    templates_available: Object.keys(DIAGRAM_TEMPLATES)
+  };
+}
+
+module.exports = {
+  generateDiagram, validateDiagram, compareDiagrams, listDiagramTypes,
+  DIAGRAM_TYPES, DIAGRAM_TEMPLATES
+};

package/bin/lib/domain-ontology.js

@@ -0,0 +1,140 @@
+/**
+ * domain-ontology.js — Domain Ontology Support (Item 83)
+ *
+ * Canonical terms, entities, events, and constraints per business domain.
+ *
+ * Usage:
+ *   node bin/lib/domain-ontology.js define|query|validate|report [options]
+ *
+ * State file: .jumpstart/state/domain-ontology.json
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_STATE_FILE = path.join('.jumpstart', 'state', 'domain-ontology.json');
+
+const ELEMENT_TYPES = ['entity', 'event', 'command', 'value-object', 'aggregate', 'constraint'];
+
+function defaultState() {
+  return { version: '1.0.0', domains: {}, last_updated: null };
+}
+
+function loadState(stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  if (!fs.existsSync(fp)) return defaultState();
+  try { return JSON.parse(fs.readFileSync(fp, 'utf8')); }
+  catch { return defaultState(); }
+}
+
+function saveState(state, stateFile) {
+  const fp = stateFile || DEFAULT_STATE_FILE;
+  const dir = path.dirname(fp);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  state.last_updated = new Date().toISOString();
+  fs.writeFileSync(fp, JSON.stringify(state, null, 2) + '\n', 'utf8');
+}
+
+function defineElement(domain, name, type, options = {}) {
+  if (!domain || !name || !type) return { success: false, error: 'domain, name, and type are required' };
+  if (!ELEMENT_TYPES.includes(type)) {
+    return { success: false, error: `Unknown type: ${type}. Valid: ${ELEMENT_TYPES.join(', ')}` };
+  }
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  if (!state.domains[domain]) state.domains[domain] = { elements: [], relationships: [] };
+
+  const element = {
+    id: `ONT-${Date.now()}`,
+    name,
+    type,
+    description: options.description || '',
+    properties: options.properties || [],
+    constraints: options.constraints || [],
+    created_at: new Date().toISOString()
+  };
+
+  state.domains[domain].elements.push(element);
+  saveState(state, stateFile);
+
+  return { success: true, element };
+}
+
+function queryOntology(domain, options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  if (!state.domains[domain]) return { success: true, domain, elements: [], total: 0 };
+
+  let elements = state.domains[domain].elements;
+  if (options.type) elements = elements.filter(e => e.type === options.type);
+
+  return { success: true, domain, elements, total: elements.length };
+}
+
+function validateTermUsage(domain, text, options = {}) {
+  if (!domain || !text) return { success: false, error: 'domain and text are required' };
+
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const domainData = state.domains[domain];
+  if (!domainData) return { success: true, domain, issues: [], canonical_terms: 0 };
+
+  const canonicalNames = domainData.elements.map(e => e.name.toLowerCase());
+  const issues = [];
+
+  // Check for near-misses
+  const words = text.toLowerCase().split(/\W+/);
+  for (const name of canonicalNames) {
+    const nameWords = name.split(/\s+/);
+    for (const nw of nameWords) {
+      if (nw.length > 3 && words.some(w => w !== nw && levenshtein(w, nw) <= 2 && levenshtein(w, nw) > 0)) {
+        issues.push({ type: 'possible_typo', canonical: name, severity: 'warning' });
+      }
+    }
+  }
+
+  return {
+    success: true,
+    domain,
+    issues,
+    canonical_terms: canonicalNames.length
+  };
+}
+
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i-1] === b[j-1] ? dp[i-1][j-1] : 1 + Math.min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]);
+  return dp[m][n];
+}
+
+function generateReport(options = {}) {
+  const stateFile = options.stateFile || DEFAULT_STATE_FILE;
+  const state = loadState(stateFile);
+
+  const domains = Object.keys(state.domains);
+  const report = { success: true, total_domains: domains.length, domains: {} };
+
+  for (const d of domains) {
+    const elements = state.domains[d].elements;
+    const byType = {};
+    for (const e of elements) byType[e.type] = (byType[e.type] || 0) + 1;
+    report.domains[d] = { total_elements: elements.length, by_type: byType };
+  }
+
+  return report;
+}
+
+module.exports = {
+  defineElement, queryOntology, validateTermUsage, generateReport,
+  loadState, saveState, defaultState,
+  ELEMENT_TYPES
+};

package/bin/lib/ea-review-packet.js

@@ -0,0 +1,151 @@
+/**
+ * ea-review-packet.js — Enterprise Architecture Review Packet (Item 32)
+ *
+ * Auto-produce diagrams, decision summaries, standards alignment,
+ * and exception lists.
+ *
+ * Usage:
+ *   node bin/lib/ea-review-packet.js generate|status [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKET_SECTIONS = ['architecture-overview', 'decision-summary', 'standards-alignment',
+  'exception-list', 'risk-assessment', 'diagrams', 'compliance-status'];
+
+/**
+ * Generate an EA review packet from project artifacts.
+ *
+ * @param {string} root - Project root.
+ * @param {object} [options]
+ * @returns {object}
+ */
+function generatePacket(root, options = {}) {
+  const packet = {
+    id: `EA-${Date.now()}`,
+    generated_at: new Date().toISOString(),
+    project_root: root,
+    sections: {}
+  };
+
+  // Architecture overview
+  const archFile = path.join(root, 'specs', 'architecture.md');
+  if (fs.existsSync(archFile)) {
+    try {
+      const content = fs.readFileSync(archFile, 'utf8');
+      const sections = content.match(/^##\s+.+$/gm) || [];
+      packet.sections['architecture-overview'] = {
+        present: true,
+        sections: sections.map(s => s.replace(/^##\s+/, '')),
+        word_count: content.split(/\s+/).length
+      };
+    } catch { packet.sections['architecture-overview'] = { present: false }; }
+  } else {
+    packet.sections['architecture-overview'] = { present: false };
+  }
+
+  // Decision summary (ADRs)
+  const decisionsDir = path.join(root, 'specs', 'decisions');
+  if (fs.existsSync(decisionsDir)) {
+    const adrs = fs.readdirSync(decisionsDir).filter(f => f.endsWith('.md'));
+    packet.sections['decision-summary'] = {
+      present: adrs.length > 0,
+      total_adrs: adrs.length,
+      adrs: adrs.map(f => f.replace('.md', ''))
+    };
+  } else {
+    packet.sections['decision-summary'] = { present: false, total_adrs: 0, adrs: [] };
+  }
+
+  // Standards alignment
+  const policyFile = path.join(root, '.jumpstart', 'policies.json');
+  if (fs.existsSync(policyFile)) {
+    try {
+      const policies = JSON.parse(fs.readFileSync(policyFile, 'utf8'));
+      packet.sections['standards-alignment'] = {
+        present: true,
+        total_policies: policies.policies ? policies.policies.length : 0
+      };
+    } catch { packet.sections['standards-alignment'] = { present: false }; }
+  } else {
+    packet.sections['standards-alignment'] = { present: false };
+  }
+
+  // Exception list (waivers)
+  const waiverFile = path.join(root, '.jumpstart', 'state', 'waivers.json');
+  if (fs.existsSync(waiverFile)) {
+    try {
+      const waivers = JSON.parse(fs.readFileSync(waiverFile, 'utf8'));
+      const active = (waivers.waivers || []).filter(w => w.status === 'approved');
+      packet.sections['exception-list'] = {
+        present: true,
+        total_exceptions: active.length,
+        exceptions: active.map(w => ({ id: w.id, title: w.title, expires_at: w.expires_at }))
+      };
+    } catch { packet.sections['exception-list'] = { present: false }; }
+  } else {
+    packet.sections['exception-list'] = { present: false, total_exceptions: 0 };
+  }
+
+  // Risk assessment
+  const riskFile = path.join(root, '.jumpstart', 'state', 'risk-register.json');
+  if (fs.existsSync(riskFile)) {
+    try {
+      const risks = JSON.parse(fs.readFileSync(riskFile, 'utf8'));
+      const highRisks = (risks.risks || []).filter(r => r.score >= 15);
+      packet.sections['risk-assessment'] = {
+        present: true,
+        total_risks: (risks.risks || []).length,
+        high_risks: highRisks.length
+      };
+    } catch { packet.sections['risk-assessment'] = { present: false }; }
+  } else {
+    packet.sections['risk-assessment'] = { present: false };
+  }
+
+  // Diagrams
+  if (fs.existsSync(archFile)) {
+    try {
+      const content = fs.readFileSync(archFile, 'utf8');
+      const mermaidBlocks = (content.match(/```mermaid/g) || []).length;
+      packet.sections.diagrams = { present: mermaidBlocks > 0, count: mermaidBlocks };
+    } catch { packet.sections.diagrams = { present: false, count: 0 }; }
+  } else {
+    packet.sections.diagrams = { present: false, count: 0 };
+  }
+
+  // Compliance status
+  const complianceFile = path.join(root, '.jumpstart', 'state', 'compliance.json');
+  if (fs.existsSync(complianceFile)) {
+    try {
+      const compliance = JSON.parse(fs.readFileSync(complianceFile, 'utf8'));
+      packet.sections['compliance-status'] = {
+        present: true,
+        frameworks: compliance.applied_frameworks || []
+      };
+    } catch { packet.sections['compliance-status'] = { present: false }; }
+  } else {
+    packet.sections['compliance-status'] = { present: false };
+  }
+
+  const presentSections = Object.values(packet.sections).filter(s => s.present).length;
+  const completeness = Math.round((presentSections / PACKET_SECTIONS.length) * 100);
+
+  return {
+    success: true,
+    packet_id: packet.id,
+    completeness,
+    sections_present: presentSections,
+    sections_total: PACKET_SECTIONS.length,
+    sections: packet.sections,
+    gaps: PACKET_SECTIONS.filter(s => !packet.sections[s] || !packet.sections[s].present)
+  };
+}
+
+module.exports = {
+  generatePacket,
+  PACKET_SECTIONS
+};

package/bin/lib/enterprise-search.js

@@ -0,0 +1,123 @@
+/**
+ * enterprise-search.js — Enterprise Search Over Artifacts (Item 96)
+ *
+ * Ask questions across specs, code, ADRs, incidents, and release records.
+ *
+ * Usage:
+ *   node bin/lib/enterprise-search.js index|search|report [options]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SEARCHABLE_TYPES = ['spec', 'code', 'adr', 'incident', 'release', 'config'];
+
+function indexProject(root, options = {}) {
+  const index = {
+    root,
+    indexed_at: new Date().toISOString(),
+    entries: []
+  };
+
+  // Index specs
+  const specsDir = path.join(root, 'specs');
+  if (fs.existsSync(specsDir)) {
+    indexDirectory(specsDir, 'spec', root, index.entries);
+  }
+
+  // Index decisions
+  const decisionsDir = path.join(root, 'specs', 'decisions');
+  if (fs.existsSync(decisionsDir)) {
+    indexDirectory(decisionsDir, 'adr', root, index.entries);
+  }
+
+  // Index source
+  const srcDir = path.join(root, 'src');
+  if (fs.existsSync(srcDir)) {
+    indexDirectory(srcDir, 'code', root, index.entries, ['.js', '.ts', '.py', '.java', '.go']);
+  }
+
+  // Index config
+  const configFile = path.join(root, '.jumpstart', 'config.yaml');
+  if (fs.existsSync(configFile)) {
+    index.entries.push({
+      type: 'config',
+      path: '.jumpstart/config.yaml',
+      size: fs.statSync(configFile).size
+    });
+  }
+
+  return { success: true, total_entries: index.entries.length, index };
+}
+
+function indexDirectory(dir, type, root, entries, extensions) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isFile()) {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (extensions && !extensions.includes(ext)) continue;
+      if (entry.name.startsWith('.')) continue;
+      const fp = path.join(dir, entry.name);
+      const relPath = path.relative(root, fp).replace(/\\/g, '/');
+      entries.push({ type, path: relPath, name: entry.name, size: fs.statSync(fp).size });
+    } else if (entry.isDirectory() && !['node_modules', '.git', 'dist'].includes(entry.name)) {
+      indexDirectory(path.join(dir, entry.name), type, root, entries, extensions);
+    }
+  }
+}
+
+function searchProject(root, query, options = {}) {
+  if (!query) return { success: false, error: 'Search query is required' };
+
+  const q = query.toLowerCase();
+  const results = [];
+  const searchDirs = [
+    { dir: path.join(root, 'specs'), type: 'spec' },
+    { dir: path.join(root, 'specs', 'decisions'), type: 'adr' },
+    { dir: path.join(root, 'src'), type: 'code' }
+  ];
+
+  for (const { dir, type } of searchDirs) {
+    if (!fs.existsSync(dir)) continue;
+    searchInDirectory(dir, q, type, root, results, options.maxResults || 20);
+  }
+
+  return {
+    success: true,
+    query,
+    total_results: results.length,
+    results: results.slice(0, options.maxResults || 20)
+  };
+}
+
+function searchInDirectory(dir, query, type, root, results, maxResults) {
+  if (!fs.existsSync(dir) || results.length >= maxResults) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (results.length >= maxResults) return;
+    if (entry.isFile() && !entry.name.startsWith('.')) {
+      try {
+        const fp = path.join(dir, entry.name);
+        const content = fs.readFileSync(fp, 'utf8');
+        if (content.toLowerCase().includes(query)) {
+          const relPath = path.relative(root, fp).replace(/\\/g, '/');
+          const lines = content.split('\n');
+          const matchingLines = lines
+            .map((l, i) => ({ line: i + 1, text: l.trim() }))
+            .filter(l => l.text.toLowerCase().includes(query))
+            .slice(0, 3);
+
+          results.push({ type, path: relPath, matches: matchingLines.length, preview: matchingLines });
+        }
+      } catch { /* skip binary/unreadable */ }
+    } else if (entry.isDirectory() && !['node_modules', '.git', 'dist'].includes(entry.name)) {
+      searchInDirectory(path.join(dir, entry.name), query, type, root, results, maxResults);
+    }
+  }
+}
+
+module.exports = {
+  indexProject, searchProject,
+  SEARCHABLE_TYPES
+};