neurain 0.1.0-alpha.0

package/src/core/adopt.mjs

@@ -0,0 +1,304 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { absPath, compactStamp, ensureDir, exists, generatedPath, isTextFile, relPath, safeResolve, sha256, slug, timestamp, writeFileNoOverwrite } from './fs.mjs';
+import { inferSensitivityFromPath, secretLike } from './safety.mjs';
+
+const maxFileBytes = 20 * 1024 * 1024;
+const maxFiles = 5000;
+
+export async function adoptCommand(args) {
+  const target = absPath(args._[0] || args.folder);
+  const dryRun = !args.apply;
+  const scan = scanAdoption(target, { dryRun });
+  if (args.apply) {
+    const expected = scan.confirmation_required;
+    if (String(args.confirm || '') !== expected) {
+      throw new Error(`Apply requires --confirm "${expected}".`);
+    }
+    scan.apply = applyAdoption(scan, { root: target });
+  }
+  if (args.json) return { json: true, payload: scan };
+  return {
+    text: [
+      '# Neurain adopt scan',
+      '',
+      `- Target: ${scan.target}`,
+      `- Dry run: ${scan.dry_run ? 'yes' : 'no'}`,
+      `- Proposed area: ${scan.proposed_area}`,
+      `- Recommended mode: ${scan.summary.recommended_mode}`,
+      `- Scanned files: ${scan.summary.scanned_files}`,
+      `- Excluded entries: ${scan.summary.excluded_entries}`,
+      `- Risks: ${scan.summary.risk_count}`,
+      `- Confirmation required: ${scan.confirmation_required}`,
+      scan.apply ? `- Apply receipt: ${scan.apply.receipt_path}` : '',
+    ].filter(Boolean).join('\n'),
+  };
+}
+
+export function scanAdoption(root, { dryRun = true } = {}) {
+  if (!exists(root)) throw new Error(`Folder does not exist: ${root}`);
+  if (!fs.statSync(root).isDirectory()) throw new Error(`Target is not a directory: ${root}`);
+
+  const rootReal = fs.realpathSync(root);
+  const files = [];
+  const excluded = [];
+  const risks = [];
+  let totalBytes = 0;
+  let truncated = false;
+
+  function rec(dir) {
+    if (files.length + excluded.length >= maxFiles) {
+      truncated = true;
+      return;
+    }
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const abs = path.join(dir, entry.name);
+      const rel = relPath(root, abs);
+      if (generatedPath(rel)) {
+        excluded.push({ rel, reason: 'generated/cache artifact' });
+        continue;
+      }
+      if (entry.isSymbolicLink()) {
+        excluded.push({ rel, reason: 'symlink excluded' });
+        risks.push({ rel, severity: 'high', reason: 'symlink requires explicit handling' });
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const real = fs.realpathSync(abs);
+        if (real !== rootReal && !real.startsWith(`${rootReal}${path.sep}`)) {
+          excluded.push({ rel, reason: 'external directory excluded' });
+          risks.push({ rel, severity: 'high', reason: 'path traversal or external directory' });
+          continue;
+        }
+        rec(abs);
+        continue;
+      }
+      if (!entry.isFile()) {
+        excluded.push({ rel, reason: 'not a regular file' });
+        continue;
+      }
+      const stat = fs.statSync(abs);
+      totalBytes += stat.size;
+      if (stat.size > maxFileBytes) {
+        excluded.push({ rel, reason: 'large file excluded from default adoption' });
+        risks.push({ rel, severity: 'medium', reason: `large file over ${maxFileBytes} bytes` });
+        continue;
+      }
+      const text = isTextFile(rel) ? safeReadText(abs) : '';
+      const secret = text ? secretLike(text) : '';
+      if (secret) risks.push({ rel, severity: 'high', reason: `secret-like content: ${secret}` });
+      files.push({
+        rel,
+        bytes: stat.size,
+        kind: classify(rel, text),
+        sensitivity: secret || inferSensitivityFromPath(rel) === 'private' ? 'private' : 'internal',
+        sha256: sha256(fs.readFileSync(abs)),
+      });
+    }
+  }
+
+  rec(root);
+  const privateCount = files.filter((f) => f.sensitivity === 'private').length;
+  const generatedRatio = excluded.length / Math.max(1, files.length + excluded.length);
+  const recommendedMode = privateCount > 0 || risks.some((risk) => risk.severity === 'high')
+    ? 'copy'
+    : generatedRatio > 0.35
+      ? 'hybrid'
+      : 'in-place';
+  const areaSlug = slug(path.basename(root), 'adopted-area');
+  const fingerprint = sha256(Buffer.from(files.map((file) => `${file.rel}:${file.sha256}`).sort().join('\n')));
+  const required = [
+    `10_areas/_${areaSlug}/_area.md`,
+    `10_areas/_${areaSlug}/index.md`,
+    `10_areas/_${areaSlug}/sources_map.md`,
+    `10_areas/_${areaSlug}/log.md`,
+  ];
+  const optional = [
+    `10_areas/_${areaSlug}/current/${areaSlug}-area-brief.md`,
+    `10_areas/_${areaSlug}/search-index/entities.json`,
+    `10_areas/_${areaSlug}/search-index/domain-routing.json`,
+  ];
+
+  return {
+    ok: true,
+    command: 'adopt',
+    generated_at: timestamp(),
+    dry_run: dryRun,
+    target: root,
+    folder_fingerprint: fingerprint,
+    proposed_area: `_${areaSlug}`,
+    summary: {
+      scanned_files: files.length,
+      excluded_entries: excluded.length,
+      total_bytes: totalBytes,
+      private_or_secret_files: privateCount,
+      risk_count: risks.length,
+      truncated,
+      recommended_mode: recommendedMode,
+    },
+    write_plan_preview: {
+      required_writes: required,
+      optional_writes: optional,
+      storage_only: ['output/receipts/adoption/<timestamp>.json'],
+    },
+    files: files.slice(0, 200),
+    excluded: excluded.slice(0, 200),
+    risks: risks.slice(0, 200),
+    confirmation_required: `${required.length + optional.length}건 저장 진행`,
+  };
+}
+
+export function applyAdoption(scan, { root = scan.target } = {}) {
+  const planned = [...scan.write_plan_preview.required_writes, ...scan.write_plan_preview.optional_writes];
+  const collisions = planned.filter((rel) => exists(safeResolve(root, rel)));
+  if (collisions.length) {
+    return { ok: false, attempted: false, reason: 'target path collision', collision_files: collisions };
+  }
+
+  const stamp = compactStamp();
+  const areaSlug = scan.proposed_area.replace(/^_+/, '');
+  const receiptRel = `output/receipts/adoption/${stamp}-${areaSlug}.json`;
+  const intentRel = `output/receipts/adoption/${stamp}-${areaSlug}-intent.json`;
+  const created = [];
+  const skipped = [];
+  const hashes = {};
+
+  ensureDir(safeResolve(root, 'output/receipts/adoption'));
+  fs.writeFileSync(safeResolve(root, intentRel), `${JSON.stringify({
+    tool: 'neurain-adopt',
+    generated_at: timestamp(),
+    planned_writes: planned,
+    target: scan.target,
+    folder_fingerprint: scan.folder_fingerprint,
+  }, null, 2)}\n`);
+
+  for (const rel of planned) {
+    const abs = safeResolve(root, rel);
+    writeFileNoOverwrite(abs, adapterContent(rel, scan, areaSlug), { created, skipped });
+    if (exists(abs)) hashes[rel] = sha256(fs.readFileSync(abs));
+  }
+
+  const receipt = {
+    ok: true,
+    tool: 'neurain-adopt',
+    generated_at: timestamp(),
+    receipt_version: 1,
+    mode: scan.summary.recommended_mode,
+    target: scan.target,
+    proposed_area: scan.proposed_area,
+    folder_fingerprint: scan.folder_fingerprint,
+    intent_path: intentRel,
+    planned_writes: planned,
+    created_files: created.map((file) => relPath(root, file)),
+    created_file_hashes: hashes,
+    skipped_existing_files: skipped.map((file) => relPath(root, file)),
+    user_owned_files_modified: [],
+    rollback_command: `neurain adopt --rollback ${receiptRel} --root "${root}"`,
+  };
+  fs.writeFileSync(safeResolve(root, receiptRel), `${JSON.stringify(receipt, null, 2)}\n`);
+  return { ...receipt, receipt_path: receiptRel };
+}
+
+export async function rollbackAdoption(args) {
+  const root = absPath(args.root || process.cwd());
+  const receiptRel = String(args.rollback);
+  const receiptAbs = safeResolve(root, receiptRel);
+  if (!exists(receiptAbs)) throw new Error(`Receipt does not exist: ${receiptRel}`);
+  const receipt = JSON.parse(fs.readFileSync(receiptAbs, 'utf8'));
+  if (receipt.tool !== 'neurain-adopt') throw new Error(`Not an adoption receipt: ${receiptRel}`);
+  const removed = [];
+  const missing = [];
+  const changed = [];
+  for (const rel of receipt.created_files || []) {
+    const abs = safeResolve(root, rel);
+    if (!exists(abs)) {
+      missing.push(rel);
+      continue;
+    }
+    const expected = receipt.created_file_hashes?.[rel];
+    if (!expected || sha256(fs.readFileSync(abs)) !== expected) {
+      changed.push(rel);
+      continue;
+    }
+    fs.rmSync(abs);
+    removed.push(rel);
+  }
+  const result = {
+    ok: missing.length === 0 && changed.length === 0,
+    tool: 'neurain-adopt-rollback',
+    source_receipt_path: receiptRel,
+    removed_files: removed,
+    missing_files: missing,
+    changed_files: changed,
+    user_owned_files_modified: [],
+  };
+  const rollbackRel = `output/receipts/adoption/${compactStamp()}-rollback.json`;
+  ensureDir(safeResolve(root, 'output/receipts/adoption'));
+  fs.writeFileSync(safeResolve(root, rollbackRel), `${JSON.stringify(result, null, 2)}\n`);
+  if (args.json) return { json: true, payload: { ...result, receipt_path: rollbackRel } };
+  return {
+    text: [
+      '# Neurain adopt rollback',
+      '',
+      `- OK: ${result.ok ? 'yes' : 'no'}`,
+      `- Removed files: ${removed.length}`,
+      `- Missing files: ${missing.length}`,
+      `- Changed files: ${changed.length}`,
+      `- Receipt: ${rollbackRel}`,
+    ].join('\n'),
+  };
+}
+
+function adapterContent(rel, scan, areaSlug) {
+  const title = areaSlug.replace(/[-_]+/g, ' ');
+  if (rel.endsWith('/_area.md')) return `# ${title}\n\n- source status: adopted\n- sensitivity: internal\n- adoption mode: ${scan.summary.recommended_mode}\n`;
+  if (rel.endsWith('/index.md')) return `# ${title} Index\n\n- [_area.md](_area.md)\n- [sources_map.md](sources_map.md)\n`;
+  if (rel.endsWith('/sources_map.md')) return `# ${title} Sources Map\n\n- Source fingerprint: ${scan.folder_fingerprint}\n- Scanned files: ${scan.summary.scanned_files}\n- Recommended mode: ${scan.summary.recommended_mode}\n`;
+  if (rel.endsWith('/log.md')) return `# ${title} Log\n\n- ${timestamp()} adopted folder adapter created.\n`;
+  if (rel.includes('/current/')) return `# ${title} Area Brief\n\nInitial adopted area brief.\n`;
+  if (rel.endsWith('entities.json')) return '[]\n';
+  if (rel.endsWith('domain-routing.json')) return '[]\n';
+  return '';
+}
+
+function classify(rel, text) {
+  const lower = rel.toLowerCase();
+  if (lower.endsWith('.md') || lower.includes('readme')) return 'source_or_note';
+  if (/\.(json|ya?ml|toml)$/.test(lower)) return 'config_or_data';
+  if (/\.(js|mjs|ts|tsx|py|rb|go|rs)$/.test(lower)) return 'code';
+  if (text) return 'text';
+  return 'binary_or_asset';
+}
+
+export { secretLike };
+
+function safeReadText(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+export function seedAdoptionFixtures(root) {
+  const clean = path.join(root, 'clean');
+  const messy = path.join(root, 'messy');
+  const risky = path.join(root, 'risky');
+  fs.mkdirSync(path.join(clean, 'docs'), { recursive: true });
+  fs.writeFileSync(path.join(clean, 'README.md'), '# Clean\n');
+  fs.writeFileSync(path.join(clean, 'docs', 'plan.md'), 'Launch notes.\n');
+  fs.mkdirSync(path.join(messy, 'node_modules'), { recursive: true });
+  fs.writeFileSync(path.join(messy, 'README.md'), '# Messy\n');
+  fs.writeFileSync(path.join(messy, 'node_modules', 'cache.js'), 'generated');
+  fs.mkdirSync(path.join(messy, '.cache'), { recursive: true });
+  fs.writeFileSync(path.join(messy, '.cache', 'blob'), 'generated');
+  fs.mkdirSync(risky, { recursive: true });
+  fs.writeFileSync(path.join(risky, 'secret.env'), `${['API', '_KEY=abc123'].join('')}\n`);
+  try {
+    fs.symlinkSync(os.tmpdir(), path.join(risky, 'external-link'));
+  } catch {
+    fs.writeFileSync(path.join(risky, 'access-token.txt'), `${['access', '_token=abc123'].join('')}\n`);
+  }
+  return { clean, messy, risky };
+}