axmap-cli 1.3.2 → 1.4.0

package/tools/reveal-demo.mjs

@@ -1,158 +0,0 @@
-#!/usr/bin/env node
-/**
- * 그래프 → 트리. `app/lib/reveal.mjs` 를 실제 저장소로 돌려 **화면 없이** 본다.
- *
- * 🔴 왜 따로 도구인가.
- *
- * 점진 공개의 주장은 "한꺼번에 다 보여주지 않으면 벽이 안 생긴다" 이고,
- * 그 주장은 **숫자로만 확인된다** — 몇 번 눌러서 몇 개를 봤나, 한 번에
- * 몇 개가 쏟아졌나, 자리가 안 바뀌었나. 브라우저에서는 이걸 셀 수 없다.
- *
- * 화면(app/web)은 다른 세션이 잡고 있다. 로직은 순수 함수라 화면 없이도
- * 전부 돌릴 수 있으므로, 여기서 먼저 재고 화면은 그 뒤에 붙인다.
- *
- * 사용:
- *   node tools/reveal-demo.mjs <저장소> [--steps 5] [--width 100]
- */
-
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { build, scan } from '../app/lib/analyze.mjs'
-import { entryStarts } from '../app/lib/flow.mjs'
-import { featureGraph } from '../app/lib/featuregraph.mjs'
-import { commitFiles } from '../app/lib/live.mjs'
-import {
-  callsOf, emptyReveal, importersOf, layers, preview, reachable, reveal, revealFeature,
-} from '../app/lib/reveal.mjs'
-
-const argv = process.argv.slice(2)
-const flag = (name, dflt) => {
-  const i = argv.indexOf(`--${name}`)
-  return i >= 0 && argv[i + 1] ? argv[i + 1] : dflt
-}
-const ROOT = path.resolve(argv.find((a) => !a.startsWith('--') && argv[argv.indexOf(a) - 1]?.startsWith('--') !== true) ?? '.')
-const STEPS = Number(flag('steps', 5))
-
-const short = (p) => (p.length <= 26 ? p : `…${p.slice(-25)}`)
-
-/** 층 하나를 한 줄로. 자리(col)가 곧 순서라 왼쪽부터 도착 순이다. */
-function draw(state, opened) {
-  const rows = layers(state)
-  const out = []
-  for (const r of rows) {
-    const cells = r.cells.map((c) => {
-      const mark = opened.has(c.id) ? '▣' : '□'
-      return `${mark} ${short(c.id)}`
-    })
-    // 한 줄이 너무 길면 접는다 — 화면에서도 줄바꿈이 일어날 자리다.
-    const head = `층 ${String(r.depth).padStart(2)} │ `
-    const pad = ' '.repeat(head.length)
-    let line = head
-    const lines = []
-    for (const c of cells) {
-      if (line.length + c.length + 3 > 96) { lines.push(line); line = pad }
-      line += `${c}   `
-    }
-    lines.push(line)
-    out.push(...lines.map((l) => l.replace(/\s+$/, '')))
-  }
-  return out.join('\n')
-}
-
-// ── 그래프를 만든다 (지금 화면이 그리는 것과 같은 재료) ────────────────────
-const g = build(scan(ROOT))
-const importers = importersOf(g.edges)
-const calls = callsOf(g.edges)
-const byId = new Map(g.nodes.map((n) => [n.id, n]))
-
-console.log(`\n저장소  ${ROOT}`)
-console.log(`━`.repeat(78))
-console.log(`지금 그래프가 한 번에 그리는 것 :  노드 ${g.nodes.length}개 · 엣지 ${g.edges.length}개`)
-console.log(`                                  ← 이것이 "벽" 이다\n`)
-
-// ── ① 진입점 하나로 시작 ──────────────────────────────────────────────────
-const starts = entryStarts(ROOT, g.nodes, g.edges)
-if (!starts.length) {
-  console.log('진입점을 못 찾았다. 이 저장소로는 시연할 수 없다.')
-  process.exit(1)
-}
-let st = reveal(emptyReveal(), [starts[0]], { why: '진입점', importers })
-const opened = new Set()
-
-console.log(`┌─ 0번째 ─ 시작`)
-console.log(draw(st, opened))
-let r = reachable(st, calls)
-console.log(`└─ 보이는 것 ${r.shown}개 · 여기서 import 로 더 닿는 것 ${r.more}개\n`)
-
-// ── ② 누른다. 누르기 **전에** 몇 개가 나올지 알려준다 ─────────────────────
-for (let step = 1; step <= STEPS; step++) {
-  // 아직 안 펼친 것 중 가장 먼저 드러난 것부터 — 사람이 위에서부터 읽는 순서
-  const target = st.order.find((id) => !opened.has(id) && preview(st, id, calls).count > 0)
-  if (!target) {
-    console.log(`더 펼칠 것이 없다 (import 사슬이 ${step - 1}번 만에 말랐다).`)
-    console.log(`🔴 이래서 개념 축이 필요하다 — 아래 참조.\n`)
-    break
-  }
-  const pv = preview(st, target, calls)
-  // 🔴 예고는 **실제로 뜨는 수**여야 한다. `count` 는 후보 전체이고 한 번에
-  //    여는 것은 `ids` 다. 둘이 다른데 후보 수를 적으면 화면이 거짓말을 한다
-  //    (개념 축에서 "고른 수와 는 수가 다르면 거짓말" 이라고 정한 것과 같다).
-  const say = pv.more ? `+${pv.ids.length}개 (후보 ${pv.count}개 중)` : `+${pv.ids.length}개`
-  console.log(`┌─ ${step}번째 ─ "${short(target)}" 를 누른다   (누르기 전 예고: ${say})`)
-  const before = { ...st.at }
-  st = reveal(st, pv.ids, { why: `${path.basename(target)} 가 부른다`, parent: target, importers })
-  opened.add(target)
-
-  // 🔴 불변식 확인 — 한 번 잡은 자리는 다시는 안 움직인다.
-  const moved = Object.keys(before).filter(
-    (k) => before[k].depth !== st.at[k].depth || before[k].col !== st.at[k].col)
-  console.log(draw(st, opened))
-  r = reachable(st, calls)
-  console.log(`└─ 보이는 것 ${r.shown}개 · 더 닿는 것 ${r.more}개 · 자리가 움직인 노드 ${moved.length}개`
-    + (moved.length ? `  ❌ 불변식 위반` : `  ✅`))
-  console.log()
-}
-
-// ── ③ 개념 축 — import 가 마르면 README 가 이름 붙인 묶음을 연다 ──────────
-let readme = null
-for (const f of ['README.md', 'README.rst', 'readme.md', 'README']) {
-  try { readme = fs.readFileSync(path.join(ROOT, f), 'utf8'); break } catch { /* 다음 후보 */ }
-}
-const { available, commits } = commitFiles(ROOT, { since: '10 years ago', maxCommits: 2000 })
-const fg = featureGraph({
-  paths: g.nodes.map((n) => n.id),
-  commits: available ? commits : [],
-  readme,
-  edges: g.edges,
-})
-const feats = (fg.nodes ?? []).filter((n) => (n.paths ?? []).length > 1)
-if (!feats.length) {
-  console.log('묶음을 못 찾았다 (README 에서 이름을 못 얻었거나 파일이 흩어져 있다).')
-} else {
-  const f = feats.sort((a, b) => b.paths.length - a.paths.length)[0]
-  console.log(`┌─ 개념 축 ─ 묶음 "${f.name ?? f.id}" 를 누른다   (안에 ${f.paths.length}개)`)
-  const before = { ...st.at }
-  const shownBefore = st.order.length
-  const out = revealFeature(st, f, { edges: g.edges, importers, byId })
-  st = out.state
-  const moved = Object.keys(before).filter(
-    (k) => before[k].depth !== st.at[k].depth || before[k].col !== st.at[k].col)
-  console.log(draw(st, opened))
-  const grew = st.order.length - shownBefore
-  console.log(`└─ ${f.paths.length}개 중 현관문 ${out.door.ids.length}개를 골랐다`)
-  console.log(`   근거: ${out.door.why}`)
-  for (const id of out.door.ids) {
-    const isNew = !before[id]
-    console.log(`     ${isNew ? '새로' : '이미'}  ${short(id).padEnd(28)} 바깥에서 부르는 곳 ${out.door.calledFrom[id]}`)
-  }
-  // 🔴 고른 수와 실제로 는 수가 다르면 사람은 "눌렀는데 아무 일도 안 났다" 를 본다.
-  console.log(`   ⇒ 화면에 실제로 는 것 ${grew}개`
-    + (grew === out.door.ids.length ? '' : `  ❌ ${out.door.ids.length}개를 골랐는데 ${out.door.ids.length - grew}개는 이미 열려 있던 것`))
-  console.log(`   자리가 움직인 노드 ${moved.length}개` + (moved.length ? ' ❌' : ' ✅'))
-}
-
-r = reachable(st, calls)
-console.log(`\n${'━'.repeat(78)}`)
-console.log(`한꺼번에 그렸다면 ${g.nodes.length}개.  ${STEPS}번 눌러서 본 것은 ${r.shown}개.`)
-console.log(`읽은 흔적이 곧 화면이고, 안 연 것은 화면에 없다.`)

package/tools/shortcut.mjs

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-/**
- * 바탕화면에 실행 바로가기를 만든다. 빌드할 때마다 **같은 자리를 덮어쓴다.**
- *
- *   $ node tools/shortcut.mjs            빌드 결과(dist)를 가리킨다
- *   $ node tools/shortcut.mjs --dev      소스에서 바로 띄우는 바로가기
- *
- * 🔴 왜 이름을 버전으로 안 나누는가.
- *
- * `axMap 0.0.2.lnk` 처럼 만들면 바탕화면에 낡은 아이콘이 쌓이고, 사람은 그중
- * 아무거나 누른다. **어제 고친 버그가 살아 있는 화면**을 보면서 도구를 탓하게
- * 된다는 뜻이다. 이름을 고정하고 덮어써서 "바탕화면의 그 아이콘 = 마지막 빌드"
- * 가 항상 참이게 한다.
- *
- * 🔴 바탕화면 경로를 `%USERPROFILE%\Desktop` 으로 짐작하지 않는다.
- *
- * OneDrive 를 쓰면 바탕화면이 `...\OneDrive\바탕 화면` 으로 옮겨 가 있고, 한국어
- * 윈도우는 폴더 이름도 다르다. 짐작하면 아무도 안 보는 자리에 파일을 만들어 놓고
- * 성공했다고 말하게 된다. 윈도우에게 직접 묻는다.
- */
-
-import { spawnSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
-const DEV = process.argv.includes('--dev')
-const NAME = 'axMap'
-
-if (process.platform !== 'win32') {
-  console.log('바로가기 만들기는 윈도우에서만 합니다 — 건너뜁니다.')
-  process.exit(0)
-}
-
-/** 윈도우가 아는 진짜 바탕화면 경로. 짐작하지 않는다. */
-function desktopDir() {
-  const r = spawnSync('powershell', ['-NoProfile', '-Command', "[Environment]::GetFolderPath('Desktop')"],
-    { encoding: 'utf8', windowsHide: true })
-  const p = r.stdout?.trim()
-  return p && fs.existsSync(p) ? p : null
-}
-
-/**
- * 무엇을 가리킬 것인가.
- *
- * 기본은 빌드 결과다. `--dev` 면 소스에서 띄운다 — 빌드하지 않고도 최신 코드를
- * 바로 볼 수 있어야 팀원이 매번 몇 분씩 기다리지 않는다.
- */
-function target() {
-  if (DEV) {
-    const electron = path.join(ROOT, 'desktop', 'node_modules', 'electron', 'dist', 'electron.exe')
-    if (!fs.existsSync(electron)) {
-      console.error('electron 이 없습니다. desktop 에서 `npm install` 을 먼저 하세요.')
-      process.exit(1)
-    }
-    return { exe: electron, args: `"${path.join(ROOT, 'desktop')}"`, cwd: path.join(ROOT, 'desktop') }
-  }
-
-  const dist = path.join(ROOT, 'desktop', 'dist', 'win-unpacked', `${NAME}.exe`)
-  if (!fs.existsSync(dist)) {
-    console.error(`빌드 결과가 없습니다: ${dist}`)
-    console.error('`npm run dist` 를 먼저 돌리거나, 소스로 띄우려면 --dev 를 주세요.')
-    process.exit(1)
-  }
-  return { exe: dist, args: '', cwd: path.dirname(dist) }
-}
-
-/**
- * 바탕화면에서 쓸 이름 — 언제나 `axMap 실행` 이다.
- *
- * 🔴 저장소가 바탕화면에 있으면 `axmap` 폴더와 `axmap` 바로가기가 나란히
- * 뜬다. 윈도우는 `.lnk` 확장자를 감추므로 **둘 다 "axmap" 으로 보인다.**
- * 실제로 그렇게 됐고, 그러면 사람은 아무거나 누른다 — 폴더를 눌러 놓고
- * "앱이 안 켜진다" 고 말하게 된다.
- *
- * 🔴 그런데 **겹칠 때만 비키게** 하면 이름이 기계마다 달라진다.
- * 저장소를 바탕화면에 둔 사람은 `axMap 실행`, 다른 데 둔 사람은 `axMap` 이
- * 생기고, 저장소를 옮기는 순간 같은 기계에서도 이름이 바뀐다. 그러면
- * README 도, 셋업 안내도, 옆자리에 하는 말("바탕화면의 axMap 실행 을 누르세요")도
- * 누군가에게는 틀린 말이 된다. 이름은 어디에 무엇이 있든 하나여야 한다.
- *
- * "실행" 을 붙여 두면 동사로 읽혀서 옆의 폴더와도 저절로 구별된다.
- */
-function linkPath(dir) {
-  return path.join(dir, `${NAME} 실행.lnk`)
-}
-
-const dir = desktopDir()
-if (!dir) { console.error('바탕화면 경로를 찾지 못했습니다.'); process.exit(1) }
-
-const { exe, args, cwd } = target()
-const link = linkPath(dir)
-const icon = path.join(ROOT, 'desktop', 'build', 'icon.ico')
-
-/**
- * `.lnk` 는 COM(WScript.Shell)으로만 만들 수 있다. 순수 Node 로는 못 만든다.
- * `$s.Save()` 는 같은 경로가 있으면 **묻지 않고 덮어쓴다** — 우리가 원하는 동작이다.
- */
-const ps = [
-  '$ErrorActionPreference = "Stop"',
-  '$w = New-Object -ComObject WScript.Shell',
-  `$s = $w.CreateShortcut("${link}")`,
-  `$s.TargetPath = "${exe}"`,
-  args ? `$s.Arguments = '${args}'` : '$s.Arguments = ""',
-  `$s.WorkingDirectory = "${cwd}"`,
-  fs.existsSync(icon) ? `$s.IconLocation = "${icon}"` : `$s.IconLocation = "${exe},0"`,
-  '$s.Description = "axMap — 코드의 변화를 사람이 이해하고 통제하는 도구"',
-  '$s.Save()',
-].join('; ')
-
-const r = spawnSync('powershell', ['-NoProfile', '-Command', ps], { encoding: 'utf8', windowsHide: true })
-if (r.status !== 0 || !fs.existsSync(link)) {
-  console.error('바로가기를 만들지 못했습니다.')
-  console.error(r.stderr || r.stdout || '(출력 없음)')
-  process.exit(1)
-}
-
-console.log(`바로가기 ${link}`)
-console.log(`  →  ${exe}${args ? ` ${args}` : ''}`)
-console.log(`  ${DEV ? '소스에서 실행 (--dev)' : '빌드 결과'} · 다음 빌드가 이 파일을 덮어씁니다`)

package/tools/smoke.mjs

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-/**
- * 화면이 실제로 뜨는지 본다.
- *
- * 🔴 `npm test` 는 화면이 죽어도 초록이다.
- *
- * 하룻밤에 두 번 겪었다. 둘 다 문법은 멀쩡했고 테스트는 전부 통과했는데
- * 브라우저에서는 아무것도 안 떴다.
- *
- *   1. 주석에 쓴 `examples/[별]/main.go` 의 `[별]/` 가 블록 주석을 닫아 파일이 깨졌다
- *   2. `let urlReady` 를 첫 사용처보다 아래에 선언해 TDZ 참조 에러가 났고,
- *      그 예외가 부트스트랩 체인을 끊어 흐름·걸음·탭이 통째로 죽었다
- *
- * 2번이 특히 나빴다. 나는 `?step=3` 으로만 확인했는데 그 경로는 크래시 지점을
- * 우회한다. **되는 길만 보면 안 되는 길은 영원히 안 보인다.**
- *
- * 그래서 여기서는 사람이 실제로 처음 여는 주소 — **맨 주소** 를 연다.
- * 자바스크립트가 다 돌고 난 DOM 에 부트스트랩이 남긴 흔적이 있는지만 본다.
- * 픽셀은 안 본다. 스크린샷 비교는 깨지기 쉽고, 우리가 잡으려는 것은
- * "화면이 통째로 안 뜨는 것" 이지 "3px 밀린 것" 이 아니다.
- *
- * 의존성은 늘리지 않는다. 이미 깔린 Chrome 을 `--dump-dom` 으로 부른다.
- */
-
-import { spawn, spawnSync, execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { detect } from '../app/lib/agentcli.mjs'
-
-const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
-const PORT = Number(process.env.AXMAP_SMOKE_PORT ?? 7912)
-/** 검사 대상은 이 저장소 자신이다. 늘 있고, 크지 않고, 결과가 안정적이다. */
-const TARGET = process.argv[2] ?? ROOT
-
-/** 이미 깔린 Chrome 을 찾는다. 없으면 **건너뛰지 않고 실패한다** — 검사는 돌아야 검사다. */
-function findChrome() {
-  if (process.env.CHROME && fs.existsSync(process.env.CHROME)) return process.env.CHROME
-  const cands = process.platform === 'win32'
-    ? [
-        'C:/Program Files/Google/Chrome/Application/chrome.exe',
-        'C:/Program Files (x86)/Google/Chrome/Application/chrome.exe',
-        path.join(process.env.LOCALAPPDATA ?? '', 'Google/Chrome/Application/chrome.exe'),
-      ]
-    : ['/usr/bin/google-chrome', '/usr/bin/chromium', '/usr/bin/chromium-browser',
-       '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome']
-  for (const c of cands) { try { if (fs.existsSync(c)) return c } catch { /* 다음 후보 */ } }
-  return null
-}
-
-/**
- * 새 껍데기(`/`)가 남겨야 하는 흔적.
- *
- * `data-shell="ready"` 는 `init()` 의 맨 끝에서 붙는다. 그 앞에 API 세 번
- * (`/api/agents` · `/api/graph` · `/api/sessions`)이 있으므로 이 한 줄이
- * **모듈 · 서버 라우트 · 세션 저장소**를 한꺼번에 증명한다.
- */
-/**
- * 처음 오는 사람이 보는 화면(`/`).
- *
- * `data-shell="ready"` 는 `init()` 의 맨 끝에서 붙는다. 그 앞에 API 세 번
- * (`/api/agents` · `/api/version` · `/api/sessions`)이 있으므로 이 한 줄이
- * **모듈 · 서버 라우트 · 세션 저장소**를 한꺼번에 증명한다.
- */
-const FIRST = [
-  { what: '부트스트랩(shell.js)', re: /data-shell="ready"/ },
-  { what: '3분할 · 왼쪽 목록', re: /id="chats"/ },
-  { what: '3분할 · 가운데', re: /id="stage"/ },
-  { what: '3분할 · 오른쪽 입력', re: /id="composer"/ },
-  { what: '모드 탭(감시·이해)', re: /data-mode="watch"/ },
-  { what: '툴바(아이콘)', re: /data-menu="all"/ },
-  /**
-   * 🔴 처음 오는 사람에게 보이는 CLI 고르기 카드.
-   * 정적 HTML 에 없다 — `/api/agents` 를 받아 `drawPicks()` 가 그린다.
-   * 이 표식이 **온보딩이 실제로 떴다**와 **CLI 감지가 돈다**를 함께 증명한다.
-   */
-  { what: '처음 설정 · CLI 고르기', re: /class="pick/ },
-]
-
-/**
- * 고르기를 끝낸 사람이 보는 화면(`/?agent=…`).
- *
- * 🔴 온보딩이 가운데 칸을 가리므로, 주소로 고른 값을 심지 않으면 렌더러가
- * 검사에서 통째로 빠진다. 헤드리스는 클릭을 못 한다.
- *
- * `data-path` 와 `class="wires"` 는 정적 HTML 에 없다 — `/api/ladder` 를 받아
- * `stage.js` 가 만든다. 둘이 **겹 계산 · 라우트 · 카드 · 버스 연결선**을 덮는다.
- */
-const OPENED = [
-  { what: '부트스트랩(shell.js)', re: /data-shell="ready"/ },
-  { what: '가운데 · 번호 카드', re: /data-path="/ },
-  { what: '가운데 · 버스 연결선', re: /class="wires"/ },
-  { what: '온보딩이 닫혔다', re: /id="onboard" hidden/ },
-]
-
-// 검사 PC의 설치된 CLI를 선택한다. 특정 팀의 Claude 설치에 의존하지 않는다.
-const agent = detect().find((a) => a.installed)
-if (!agent) {
-  console.error('온보딩 이후 화면 검증에 필요한 AI CLI가 없습니다. Claude Code, agy 또는 Codex CLI를 설치하세요.')
-  process.exit(1)
-}
-
-const PAGES = [
-  { path: '/', what: '처음 오는 사람', must: FIRST },
-  { path: `/?agent=${encodeURIComponent(agent.id)}`, what: '고르기를 끝낸 사람', must: OPENED },
-]
-
-async function waitUp(ms = 120_000) {
-  const until = Date.now() + ms
-  while (Date.now() < until) {
-    try {
-      await fetch(`http://127.0.0.1:${PORT}/`, { signal: AbortSignal.timeout(2000) })
-      return true
-    } catch { await new Promise((r) => setTimeout(r, 400)) }
-  }
-  return false
-}
-
-const chrome = findChrome()
-if (!chrome) {
-  console.error('Chrome 을 찾지 못했습니다. CHROME=<경로> 로 알려주세요.')
-  console.error('건너뛰지 않습니다 — 안 도는 검사는 검사가 아닙니다.')
-  process.exit(1)
-}
-
-// 이미 그 포트를 쓰고 있으면 그것을 재사용하지 않는다. 무엇을 검사했는지가 흐려진다.
-const log = path.join(ROOT, '.axmap-smoke.log')
-const out = fs.openSync(log, 'w')
-const server = spawn(process.execPath, [path.join(ROOT, 'app', 'server.mjs'), TARGET, String(PORT)],
-  { cwd: ROOT, stdio: ['ignore', out, out], windowsHide: true })
-
-let failed = 0
-try {
-  if (!await waitUp()) {
-    console.error(`서버가 뜨지 않았습니다. 기록: ${log}`)
-    try { console.error(fs.readFileSync(log, 'utf8').split('\n').slice(-10).join('\n')) } catch { /* 없으면 그만 */ }
-    process.exit(1)
-  }
-
-  console.log(`대상 ${TARGET}`)
-
-  for (const page of PAGES) {
-    // 🔴 맨 주소로 연다. 사람이 처음 여는 주소가 이것이고, 파라미터를 붙이면
-    //    부트스트랩의 다른 갈래를 타서 크래시 지점을 우회할 수 있다.
-    const dom = execFileSync(chrome, [
-      '--headless=new', '--disable-gpu', '--no-sandbox',
-      // 자바스크립트가 끝날 시간을 준다. 큰 저장소는 그래프를 만드느라 느리다.
-      '--virtual-time-budget=20000',
-      '--dump-dom', `http://127.0.0.1:${PORT}${page.path}`,
-    ], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, windowsHide: true })
-
-    console.log(`\n${page.path}  ${page.what}  ·  DOM ${dom.length.toLocaleString()} bytes`)
-    for (const m of page.must) {
-      const ok = m.re.test(dom)
-      console.log(`  ${ok ? '통과' : '실패'}  ${m.what}`)
-      if (!ok) failed++
-    }
-  }
-
-  if (failed) {
-    console.error('\n화면이 뜨지 않았습니다 — 부트스트랩이 중간에 죽었을 수 있습니다.')
-    console.error('브라우저 콘솔을 보세요. 문법은 멀쩡한데 실행이 죽는 경우가 많습니다')
-    console.error('(선언 순서·TDZ·없는 id 참조).')
-  }
-} finally {
-  try { server.kill() } catch { /* 이미 죽었으면 그만 */ }
-  if (process.platform === 'win32') {
-    try { spawnSync('taskkill', ['/PID', String(server.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true }) } catch { /* 그만 */ }
-  }
-  try { fs.closeSync(out) } catch { /* 그만 */ }
-}
-
-if (failed) process.exit(1)
-console.log('\n화면 연기 검사 통과')

package/tools/topicgraph.py

@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""
-토픽 그래프 측정기 — docs/DECISIONS.md 의 D5·D6·D7·D9·D10 근거를 재현한다.
-
-ROS2 처럼 배선이 문자열로 표현되는 코드베이스에서
-"어떤 파일이 어떤 파일과 이어져 있고, 시작점에서 몇 단계 떨어져 있는가"를 센다.
-
-    python tools/topicgraph.py <소스루트> [시작파일] [--hub-cap N]
-
-    python tools/topicgraph.py ../e101_hj/redesign/.../ros2_ws/src \\
-        bbiyong_base/bbiyong_base/cmd_mux_node.py --hub-cap 6
-
-이것은 제품이 아니라 **측정 도구**다. 정적 문자열만 본다.
-그래서 파라미터를 통한 간접 배선을 놓치며, 실제로 놓쳤다 (DECISIONS.md D5).
-그 한계를 보여주는 것도 이 스크립트의 역할이다.
-"""
-
-import argparse
-import collections
-import os
-import re
-import sys
-
-if hasattr(sys.stdout, "reconfigure"):
-    sys.stdout.reconfigure(encoding="utf-8")
-
-TOPIC = re.compile(r'["\'](/[A-Za-z0-9_/]{2,})["\']')
-
-
-def collect(root):
-    """파일별로 등장하는 토픽 문자열을 모은다."""
-    files = {}
-    for dirpath, dirnames, filenames in os.walk(root):
-        dirnames[:] = [d for d in dirnames if d != "__pycache__"]
-        for name in filenames:
-            if not name.endswith(".py"):
-                continue
-            path = os.path.join(dirpath, name)
-            try:
-                src = open(path, encoding="utf-8", errors="ignore").read()
-            except OSError:
-                continue
-            topics = set(TOPIC.findall(src))
-            if topics:
-                files[os.path.relpath(path, root).replace("\\", "/")] = topics
-    return files
-
-
-def layers_from(topic_files, start, hub_cap=None):
-    """
-    시작 파일에서 너비우선으로 뻗어나가며 깊이별 파일 집합을 만든다.
-
-    hub_cap 을 주면 그보다 많은 파일이 공유하는 토픽은 엣지에서 제외한다.
-    전역 방송 신호(/estop 등)가 무관한 노드들을 서로 1홉 거리로 만드는 것을 막는다.
-    """
-    adj = collections.defaultdict(set)
-    for topic, group in topic_files.items():
-        if hub_cap is not None and len(group) > hub_cap:
-            continue
-        for a in group:
-            adj[a] |= group - {a}
-
-    seen, out, frontier = {start}, [], {start}
-    while frontier:
-        nxt = set()
-        for node in frontier:
-            nxt |= adj[node] - seen
-        if not nxt:
-            break
-        seen |= nxt
-        out.append(nxt)
-        frontier = nxt
-    return out
-
-
-def size_histogram(root):
-    buckets = [("<100", 0), ("100-300", 0), ("300-600", 0), ("600-1000", 0), ("1000+", 0)]
-    counts = dict(buckets)
-    total_lines = 0
-    biggest = []
-    for dirpath, dirnames, filenames in os.walk(root):
-        dirnames[:] = [d for d in dirnames if d != "__pycache__"]
-        for name in filenames:
-            if not name.endswith(".py"):
-                continue
-            path = os.path.join(dirpath, name)
-            try:
-                n = sum(1 for _ in open(path, encoding="utf-8", errors="ignore"))
-            except OSError:
-                continue
-            total_lines += n
-            biggest.append((n, os.path.relpath(path, root).replace("\\", "/")))
-            key = ("<100" if n < 100 else "100-300" if n < 300 else
-                   "300-600" if n < 600 else "600-1000" if n < 1000 else "1000+")
-            counts[key] += 1
-    biggest.sort(reverse=True)
-    return counts, total_lines, biggest
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("root")
-    ap.add_argument("start", nargs="?")
-    ap.add_argument("--hub-cap", type=int, default=6)
-    args = ap.parse_args()
-
-    files = collect(args.root)
-    topic_files = collections.defaultdict(set)
-    for f, topics in files.items():
-        for t in topics:
-            topic_files[t].add(f)
-
-    counts, total_lines, biggest = size_histogram(args.root)
-    n_files = sum(counts.values())
-
-    print(f"== 규모 ==")
-    print(f"  {n_files}개 .py, {total_lines:,}줄")
-    print(f"  토픽 문자열을 가진 파일 {len(files)}개, 토픽 {len(topic_files)}개\n")
-
-    print("== 크기 분포 ==")
-    for label in ["<100", "100-300", "300-600", "600-1000", "1000+"]:
-        print(f"  {label:>9}줄  {counts[label]:3}개")
-    tail = sum(n for n, _ in biggest[:5])
-    if total_lines:
-        print(f"  상위 5개 파일이 전체의 {tail / total_lines * 100:.0f}% ({tail:,}줄)")
-    for n, f in biggest[:5]:
-        print(f"      {n:5}줄  {f}")
-    print()
-
-    print(f"== 허브 토픽 (많은 파일이 공유) ==")
-    for t, group in sorted(topic_files.items(), key=lambda kv: -len(kv[1]))[:6]:
-        flag = "  ← 허브" if len(group) > args.hub_cap else ""
-        print(f"  {len(group):3}개 파일  {t}{flag}")
-    print()
-
-    if not args.start:
-        print("시작 파일을 주면 깊이별 확산을 잽니다.")
-        return
-    if args.start not in files:
-        print(f"시작 파일을 찾을 수 없습니다: {args.start}")
-        return
-
-    for cap, label in [(None, "허브 제한 없음"), (args.hub_cap, f"{args.hub_cap}개 초과 토픽 제외")]:
-        print(f"== {args.start} 로부터의 깊이 ({label}) ==")
-        total = 1
-        for depth, group in enumerate(layers_from(topic_files, args.start, cap), 1):
-            total += len(group)
-            mark = "  ← 요약 한계" if depth == 3 else ""
-            print(f"  깊이 {depth}: +{len(group):3}개  (누적 {total:3}){mark}")
-        print()
-
-
-if __name__ == "__main__":
-    main()