wize-dev-kit 0.2.5 → 0.3.1

package/tools/installer/commands/document-project.js

@@ -0,0 +1,93 @@
+// `wize-dev-kit document-project` — CLI command entry point.
+//
+// Parses mode + flags and delegates to the appropriate scan implementation.
+// Non-quick modes are stubs here; later stories fill them in.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { runQuick } = require('../document-project/modes/quick.js');
+const { runInitialScan } = require('../document-project/modes/initial-scan.js');
+const { runFullRescan } = require('../document-project/modes/full-rescan.js');
+const { runDeepDive } = require('../document-project/modes/deep-dive.js');
+const { loadState, archiveOldState } = require('../document-project/state.js');
+
+const VALID_MODES = new Set(['quick', 'initial_scan', 'full_rescan', 'deep_dive']);
+const VALID_SCAN_LEVELS = new Set(['quick', 'deep', 'exhaustive']);
+
+function parseMode(args) {
+  let mode = 'quick';
+  let resume = false;
+  let scanLevel = 'quick';
+  let target = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--resume') {
+      resume = true;
+      continue;
+    }
+    if (arg === '--target') {
+      target = args[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      return { mode: null, error: `unknown option: ${arg}` };
+    }
+    if (VALID_SCAN_LEVELS.has(arg)) {
+      scanLevel = arg;
+      continue;
+    }
+    if (mode === 'quick' && VALID_MODES.has(arg)) {
+      mode = arg;
+    } else if (mode === 'quick') {
+      return { mode: null, error: `unknown mode: ${arg}. Valid modes: ${[...VALID_MODES].join(', ')}` };
+    } else {
+      return { mode: null, error: `unexpected extra argument: ${arg}` };
+    }
+  }
+
+  if (!VALID_MODES.has(mode)) {
+    return { mode: null, error: `unknown mode: ${mode}. Valid modes: ${[...VALID_MODES].join(', ')}` };
+  }
+
+  return { mode, resume, scanLevel, target };
+}
+
+function cmdDocumentProject({ kitRoot, projectRoot, args = [], opts = {} }) {
+  const log = opts.log || console.log;
+  const parsed = parseMode(args);
+
+  if (parsed.mode === null) {
+    log(parsed.error);
+    return { ok: false, error: parsed.error, exitCode: 1 };
+  }
+
+  if (parsed.mode === 'quick') {
+    const r = runQuick(projectRoot, { log });
+    return { ok: true, mode: 'quick', ...r };
+  }
+
+  if (parsed.mode === 'initial_scan') {
+    const r = runInitialScan(projectRoot, { scanLevel: parsed.scanLevel, log });
+    return { ok: true, mode: 'initial_scan', ...r };
+  }
+
+  if (parsed.mode === 'full_rescan') {
+    const r = runFullRescan(projectRoot, { scanLevel: parsed.scanLevel, log });
+    return { ok: true, mode: 'full_rescan', ...r };
+  }
+
+  if (parsed.mode === 'deep_dive') {
+    const r = runDeepDive(projectRoot, { target: parsed.target, log });
+    return r;
+  }
+
+  log(`document-project ${parsed.mode} not implemented`);
+  return { ok: false, error: 'not implemented', exitCode: 1 };
+}
+
+module.exports = { cmdDocumentProject, parseMode };
+

package/tools/installer/document-project/batch-scanner.js

@@ -0,0 +1,93 @@
+// Batch scanner for `wize-dev-kit document-project`.
+//
+// Walks a repo in subfolder-sized batches, skipping noise directories.
+// Returns summaries without loading entire trees into memory.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_IGNORE = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'coverage',
+  '.cache',
+  '.tmp',
+  '.wize',
+  '.claude',
+  '.cursor',
+  '.kimi',
+  '.opencode',
+  '.windsurf',
+  '.continue',
+  '.codex',
+  '.antigravity'
+]);
+
+const MAX_FILE_LOC = 5000;
+
+function shouldIgnore(name, customIgnore = []) {
+  if (DEFAULT_IGNORE.has(name)) return true;
+  for (const pattern of customIgnore) {
+    if (name === pattern || (pattern.startsWith('*') && name.endsWith(pattern.slice(1)))) return true;
+  }
+  return false;
+}
+
+function listSubfolders(rootDir, options = {}) {
+  const out = [];
+  let entries;
+  try { entries = fs.readdirSync(rootDir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (shouldIgnore(e.name, options.ignore)) continue;
+    out.push(path.join(rootDir, e.name));
+  }
+  return out;
+}
+
+function scanFolder(folderPath, options = {}) {
+  const files = [];
+  let totalLoc = 0;
+  const stack = [folderPath];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!shouldIgnore(e.name, options.ignore)) stack.push(full);
+        continue;
+      }
+      if (!e.isFile()) continue;
+      if (/\.(min\.js|map)$/.test(e.name)) continue;
+      const stat = fs.statSync(full);
+      const loc = stat.size; // proxy; exact line count is optional
+      const info = {
+        path: full,
+        relative: path.relative(folderPath, full),
+        size: stat.size,
+        loc: loc > MAX_FILE_LOC ? MAX_FILE_LOC : loc,
+        skipped: loc > MAX_FILE_LOC
+      };
+      files.push(info);
+      totalLoc += info.loc;
+    }
+  }
+  return { folder: folderPath, files, totalLoc, fileCount: files.length };
+}
+
+function batchScanner(rootDir, options = {}) {
+  const folders = options.folders || listSubfolders(rootDir, options);
+  const results = [];
+  for (const folder of folders) {
+    results.push(scanFolder(folder, options));
+  }
+  return results;
+}
+
+module.exports = { batchScanner, listSubfolders, scanFolder, shouldIgnore, MAX_FILE_LOC };

package/tools/installer/document-project/classify.js

@@ -0,0 +1,170 @@
+// Project-type classifier for `wize-dev-kit document-project`.
+//
+// Detects the project type(s) of a repo from file patterns, then decides
+// whether the repo is a monolith, multi-part, or monorepo.
+// No source files are read — this is pattern-only detection.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MULTI_PART_FOLDERS = ['client', 'server', 'api', 'web', 'app', 'frontend', 'backend', 'mobile', 'desktop'];
+
+function toBool(v) {
+  return String(v).toLowerCase() === 'true';
+}
+
+function splitPatterns(str) {
+  if (!str || str === 'N/A') return [];
+  return str.split(';').map(s => s.trim()).filter(Boolean);
+}
+
+function loadRequirements(csvPath) {
+  const content = fs.readFileSync(csvPath, 'utf-8');
+  const lines = content.split(/\r?\n/).filter(l => l.trim());
+  const header = lines[0].split(',').map(h => h.trim());
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = lines[i].split(',').map(v => v.trim());
+    const row = {};
+    for (let j = 0; j < header.length; j++) {
+      const key = header[j];
+      const raw = values[j];
+      if (key.startsWith('requires_')) {
+        row[key] = toBool(raw);
+      } else {
+        row[key] = raw || '';
+      }
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+function globMatch(rootDir, pattern) {
+  // Very small pattern matcher: supports * wildcard and trailing / for dirs.
+  const isDirPattern = pattern.endsWith('/');
+  const base = isDirPattern ? pattern.slice(0, -1) : pattern;
+  const parts = base.split('/');
+  return walkMatch(rootDir, parts, 0, isDirPattern);
+}
+
+function walkMatch(dir, parts, depth, isDirPattern) {
+  if (depth >= parts.length) return true;
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return false; }
+  const part = parts[depth];
+  const isLast = depth === parts.length - 1;
+  const regex = globToRegex(part);
+  for (const e of entries) {
+    if (!regex.test(e.name)) continue;
+    if (isLast) {
+      if (isDirPattern && e.isDirectory()) return true;
+      if (!isDirPattern && e.isFile()) return true;
+      if (!isDirPattern && e.isDirectory()) {
+        // pattern like vite.config.* can match a directory named vite.config.ts? no.
+        // But pattern may be a prefix; treat directory match as false for files.
+        return false;
+      }
+    } else if (e.isDirectory()) {
+      if (walkMatch(path.join(dir, e.name), parts, depth + 1, isDirPattern)) return true;
+    }
+  }
+  return false;
+}
+
+function globToRegex(pattern) {
+  const escaped = pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  return new RegExp(`^${escaped}$`);
+}
+
+function scorePart(rootDir, row, { prefer = [] } = {}) {
+  let score = 0;
+  const keyPatterns = splitPatterns(row.key_file_patterns);
+  const dirPatterns = splitPatterns(row.critical_directories);
+  for (const p of keyPatterns) {
+    if (globMatch(rootDir, p)) score += 2;
+  }
+  for (const p of dirPatterns) {
+    if (globMatch(rootDir, p)) score += 1;
+  }
+  if (prefer.includes(row.project_type_id)) score += 0.5;
+  return score;
+}
+
+function detectParts(rootDir) {
+  const parts = [];
+  const candidates = [];
+  let entries;
+  try { entries = fs.readdirSync(rootDir, { withFileTypes: true }); } catch { return parts; }
+
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (!MULTI_PART_FOLDERS.includes(e.name.toLowerCase())) continue;
+    candidates.push(e.name);
+  }
+
+  if (candidates.length < 2) return parts;
+
+  const rows = loadRequirements(requirementsPath());
+  for (const partId of candidates) {
+    const partRoot = path.join(rootDir, partId);
+    const prefer = partId.toLowerCase() === 'server' || partId.toLowerCase() === 'backend' ? ['backend'] : [];
+    const scored = rows.map(r => ({ ...r, score: scorePart(partRoot, r, { prefer }) }));
+    scored.sort((a, b) => b.score - a.score);
+    const best = scored[0];
+    if (best && best.score > 0) {
+      parts.push({ part_id: partId, project_type_id: best.project_type_id, root_path: partRoot });
+    }
+  }
+  return parts;
+}
+
+function isMultiPart(rootDir) {
+  return detectParts(rootDir).length >= 2;
+}
+
+function classifyProject(rootDir, options = {}) {
+  const csvPath = options.csvPath || requirementsPath();
+  const rows = loadRequirements(csvPath);
+  const parts = detectParts(rootDir);
+
+  if (parts.length >= 2) {
+    return { projectTypes: [...new Set(parts.map(p => p.project_type_id))], parts };
+  }
+
+  const scored = rows.map(r => ({ ...r, score: scorePart(rootDir, r, { prefer: options.prefer || [] }) }));
+  scored.sort((a, b) => b.score - a.score);
+  const best = scored[0];
+  const tied = scored.filter(s => s.score === best.score).map(s => s.project_type_id);
+
+  if (!best || best.score === 0) {
+    return { projectTypes: [], parts: [] };
+  }
+
+  // Cli + library often appear together; prefer both when tied at the top.
+  const projectTypes = tied.includes('cli') && tied.includes('library')
+    ? ['cli', 'library']
+    : [best.project_type_id];
+
+  return {
+    projectTypes,
+    parts: [{ part_id: 'root', project_type_id: best.project_type_id, root_path: rootDir }]
+  };
+}
+
+function requirementsPath() {
+  // When running from the installed package, the CSV is next to this file under
+  // node_modules/wize-dev-kit/... When running from the source repo, resolve from
+  // the repo root via the known relative path.
+  const installed = path.resolve(__dirname, '..', '..', '..', 'src', 'method-skills', '1-analysis', 'wize-document-project', 'documentation-requirements.csv');
+  if (fs.existsSync(installed)) return installed;
+  // Fallback for source repo layout.
+  return path.resolve(__dirname, '..', '..', '..', '..', 'src', 'method-skills', '1-analysis', 'wize-document-project', 'documentation-requirements.csv');
+}
+
+module.exports = { classifyProject, loadRequirements, isMultiPart, scorePart, requirementsPath, globMatch };

package/tools/installer/document-project/modes/deep-dive.js

@@ -0,0 +1,196 @@
+// Deep-dive mode for `wize-dev-kit document-project`.
+//
+// Exhaustive documentation of a specific folder/file/feature.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { batchScanner, scanFolder } = require('../batch-scanner.js');
+const { updateState } = require('../state.js');
+const { renderIndex } = require('../render-index.js');
+
+function sanitize(name) {
+  return name.replace(/[^a-z0-9_-]/gi, '-').toLowerCase();
+}
+
+function walkAllFiles(rootDir, ignore = ['node_modules', '.git', 'dist', 'build', 'coverage']) {
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!ignore.includes(e.name)) stack.push(full);
+        continue;
+      }
+      if (e.isFile() && /\.(js|ts|jsx|tsx|mjs|cjs)$/.test(e.name)) files.push(full);
+    }
+  }
+  return files;
+}
+
+function matchesTarget(filePath, projectRoot, targetType, targetName) {
+  const rel = path.relative(projectRoot, filePath).toLowerCase();
+  const name = targetName.toLowerCase();
+  if (targetType === 'feature') {
+    return rel.includes(name);
+  }
+  if (targetType === 'api_group') {
+    const inApiFolder = /\/(routes|api|controllers|endpoints)\//.test(rel);
+    return inApiFolder && rel.includes(name);
+  }
+  if (targetType === 'component_group') {
+    const inComponentFolder = /\/(components|ui|widgets)\//.test(rel);
+    return inComponentFolder && rel.includes(name);
+  }
+  return false;
+}
+
+function resolveTarget(projectRoot, target) {
+  if (!target) return { targetType: null, targetName: null, targetPath: null, files: [] };
+
+  // Explicit typed target: "feature:auth", "api:users", "component:Button"
+  const typedMatch = target.match(/^([a-z_]+):(.+)$/i);
+  if (typedMatch) {
+    const targetType = typedMatch[1].toLowerCase();
+    const targetName = typedMatch[2];
+    if (['feature', 'api_group', 'component_group'].includes(targetType)) {
+      const all = walkAllFiles(projectRoot);
+      const files = all.filter(f => matchesTarget(f, projectRoot, targetType, targetName));
+      return { targetType, targetName, targetPath: target, files };
+    }
+    return { targetType, targetName, targetPath: target, files: [], error: `unknown target type: ${targetType}` };
+  }
+
+  // Path-based target (folder or file)
+  const targetPath = path.resolve(projectRoot, target);
+  if (fs.existsSync(targetPath)) {
+    const stats = fs.statSync(targetPath);
+    const targetType = stats.isFile() ? 'file' : 'folder';
+    const files = stats.isFile() ? [targetPath] : scanFolder(targetPath, { ignore: ['node_modules', '.git', 'dist', 'build', 'coverage'] }).files.map(f => f.path);
+    return { targetType, targetName: path.basename(targetPath), targetPath, files };
+  }
+
+  // Bare name treated as feature search
+  const all = walkAllFiles(projectRoot);
+  const files = all.filter(f => matchesTarget(f, projectRoot, 'feature', target));
+  return { targetType: 'feature', targetName: target, targetPath: target, files };
+}
+
+function listFilesInScope(rootDir, targetPath) {
+  const stats = fs.statSync(targetPath);
+  if (stats.isFile()) return [targetPath];
+  const scan = scanFolder(targetPath, { ignore: ['node_modules', '.git', 'dist', 'build', 'coverage'] });
+  return scan.files.map(f => f.path);
+}
+
+function readFileSummary(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const exports = [];
+    const todos = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (/\b(module\.exports|exports\.|export\s+(default\s+)?|function\s+|class\s+)/.test(line)) {
+        exports.push(line.trim().slice(0, 80));
+      }
+      if (/\b(TODO|FIXME|HACK|XXX)\b/i.test(line)) {
+        todos.push(`${i + 1}: ${line.trim().slice(0, 80)}`);
+      }
+    }
+    return {
+      path: filePath,
+      loc: lines.length,
+      exports: exports.slice(0, 10),
+      todos: todos.slice(0, 10)
+    };
+  } catch {
+    return { path: filePath, loc: 0, exports: [], todos: [] };
+  }
+}
+
+function runDeepDive(projectRoot, { target, log = console.log } = {}) {
+  if (!target) {
+    return { ok: false, error: 'missing --target for deep_dive', exitCode: 1 };
+  }
+
+  const resolved = resolveTarget(projectRoot, target);
+  if (resolved.error) {
+    return { ok: false, error: resolved.error, exitCode: 1 };
+  }
+  if (resolved.targetType === 'file' || resolved.targetType === 'folder') {
+    if (!fs.existsSync(resolved.targetPath)) {
+      return { ok: false, error: `target not found: ${target}`, exitCode: 1 };
+    }
+  }
+  if (resolved.files.length === 0) {
+    return { ok: false, error: `target not found or no files matched: ${target}`, exitCode: 1 };
+  }
+
+  const files = resolved.files;
+  const summaries = files.map(readFileSummary);
+  const targetName = resolved.targetName;
+  const outputName = `deep-dive-${sanitize(targetName)}.md`;
+  const outputPath = path.join(projectRoot, '.wize', 'knowledge', 'document-project', outputName);
+
+  const lines = [
+    '---',
+    'status: baseline',
+    'owner: Pepper Potts + Tony Stark',
+    `created: ${new Date().toISOString().slice(0, 10)}`,
+    `last_refreshed: ${new Date().toISOString().slice(0, 10)}`,
+    '---',
+    '',
+    `# Deep Dive — ${targetName}`,
+    '',
+    `**Type:** ${resolved.targetType}`,
+    `**Scope:** ${target}`,
+    `**Files analyzed:** ${files.length}`,
+    '',
+    '## File Inventory',
+    ''
+  ];
+
+  for (const s of summaries) {
+    lines.push(`### ${path.relative(projectRoot, s.path)}`);
+    lines.push(`- **LOC:** ${s.loc}`);
+    if (s.exports.length) {
+      lines.push('- **Exports/signatures:**');
+      for (const e of s.exports) lines.push(`  - \`${e}\``);
+    }
+    if (s.todos.length) {
+      lines.push('- **TODOs/FIXMEs:**');
+      for (const t of s.todos) lines.push(`  - ${t}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('## Modification Guidance', '', '- Verify tests before changing exported signatures.', '');
+
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, lines.join('\n'), 'utf-8');
+
+  updateState(projectRoot, {
+    deep_dive_targets: [{
+      target_name: targetName,
+      target_path: resolved.targetPath,
+      files_analyzed: files.length,
+      output_file: outputName,
+      timestamp: new Date().toISOString()
+    }],
+    outputs_generated: [outputName]
+  });
+
+  // Update master index with a link to this deep-dive doc.
+  renderIndex(projectRoot, { deepDiveFiles: [outputName] });
+
+  log(`Deep-dive written to ${outputPath}`);
+  return { ok: true, mode: 'deep_dive', changed: true, written: [outputName] };
+}
+
+module.exports = { runDeepDive, listFilesInScope, readFileSummary, resolveTarget };

package/tools/installer/document-project/modes/full-rescan.js

@@ -0,0 +1,15 @@
+// Full rescan mode for `wize-dev-kit document-project`.
+//
+// Archives the previous state and re-runs an initial scan from scratch.
+
+'use strict';
+
+const { archiveOldState } = require('../state.js');
+const { runInitialScan } = require('./initial-scan.js');
+
+function runFullRescan(projectRoot, options = {}) {
+  archiveOldState(projectRoot);
+  return runInitialScan(projectRoot, { ...options, mode: 'full_rescan' });
+}
+
+module.exports = { runFullRescan };

package/tools/installer/document-project/modes/initial-scan.js

@@ -0,0 +1,100 @@
+// Initial scan mode for `wize-dev-kit document-project`.
+//
+// Runs project-type classification, conditional scans, and generates index + docs.
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { classifyProject } = require('../classify.js');
+const { batchScanner } = require('../batch-scanner.js');
+const { renderIndex } = require('../render-index.js');
+const { initState, updateState } = require('../state.js');
+const { runQuick } = require('./quick.js');
+
+function now() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function readRequirements(row) {
+  return {
+    api: row.requires_api_scan,
+    data: row.requires_data_models,
+    state: row.requires_state_management,
+    ui: row.requires_ui_components,
+    deploy: row.requires_deployment_config,
+    hardware: row.requires_hardware_docs,
+    assets: row.requires_asset_inventory
+  };
+}
+
+function existingDocs(root) {
+  const candidates = [
+    'README.md',
+    'CONTRIBUTING.md',
+    'ARCHITECTURE.md',
+    'DEPLOYMENT.md',
+    'API.md'
+  ];
+  return candidates.filter(f => fs.existsSync(path.join(root, f))).map(f => path.join(root, f));
+}
+
+function runInitialScan(projectRoot, { scanLevel = 'quick', log = console.log, csvPath } = {}) {
+  const classification = classifyProject(projectRoot, csvPath ? { csvPath } : {});
+  const state = initState(projectRoot, 'initial_scan', scanLevel);
+
+  updateState(projectRoot, {
+    completed_steps: [{ step: 'classify', status: 'completed', timestamp: new Date().toISOString(), summary: `Classified as ${classification.projectTypes.join(', ')}` }],
+    current_step: 'scan',
+    findings: {
+      project_classification: {
+        repository_type: classification.parts.length >= 2 ? 'multi-part' : 'monolith',
+        parts_count: classification.parts.length,
+        primary_language: 'unknown',
+        architecture_type: classification.projectTypes[0] || 'unknown'
+      }
+    }
+  });
+
+  let generated = [];
+  if (scanLevel === 'deep' || scanLevel === 'exhaustive') {
+    const batches = batchScanner(projectRoot, { ignore: ['.wize', '.git', 'node_modules'] });
+    updateState(projectRoot, {
+      completed_steps: [{ step: 'scan', status: 'completed', timestamp: new Date().toISOString(), summary: `${batches.length} batches scanned` }],
+      current_step: 'generate',
+      findings: {
+        batches_completed: batches.map(b => ({ path: b.folder, files_scanned: b.fileCount, summary: `${b.totalLoc} LOC` }))
+      }
+    });
+  }
+
+  // Always write baseline + index.
+  const quick = runQuick(projectRoot, { log });
+  generated.push(...quick.written.map(f => path.join(projectRoot, '.wize', 'knowledge', 'document-project', f)));
+
+  const indexResult = renderIndex(projectRoot, {
+    projectTypes: classification.projectTypes,
+    parts: classification.parts,
+    generated,
+    existing: existingDocs(projectRoot)
+  });
+  generated.push(path.join(projectRoot, '.wize', 'knowledge', 'document-project', 'index.md'));
+
+  updateState(projectRoot, {
+    completed_steps: [{ step: 'generate', status: 'completed', timestamp: new Date().toISOString(), summary: `Generated ${generated.length} files` }],
+    current_step: 'completed',
+    outputs_generated: generated.map(g => path.basename(g)),
+    resume_instructions: 'Scan complete'
+  });
+
+  return {
+    changed: true,
+    mode: 'initial_scan',
+    scanLevel,
+    projectTypes: classification.projectTypes,
+    parts: classification.parts,
+    generated: generated.map(g => path.basename(g))
+  };
+}
+
+module.exports = { runInitialScan };