byuckchon-frontend-cli 1.1.0 → 1.4.1

package/src/indexer/store.js

@@ -0,0 +1,137 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { findProjectConfigPath } from '../config/index.js';
+import { walkProjectFiles, relPath } from './walker.js';
+import { chunkFile } from './chunker.js';
+import { embedChunks, DEFAULT_EMBED_MODEL } from './embed.js';
+
+const INDEX_VERSION = 1;
+
+export async function getIndexPaths(cwd = process.cwd()) {
+  const projectConfig = await findProjectConfigPath(cwd);
+  const projectRoot = projectConfig ? path.dirname(projectConfig) : cwd;
+  const dir = path.join(projectRoot, '.bc', 'index');
+  return {
+    projectRoot,
+    dir,
+    manifest: path.join(dir, 'manifest.json'),
+    chunks: path.join(dir, 'chunks.json'),
+  };
+}
+
+export async function loadIndex(cwd = process.cwd()) {
+  const p = await getIndexPaths(cwd);
+  try {
+    const [manifestRaw, chunksRaw] = await Promise.all([
+      fs.readFile(p.manifest, 'utf8'),
+      fs.readFile(p.chunks, 'utf8'),
+    ]);
+    return {
+      ...JSON.parse(manifestRaw),
+      chunks: JSON.parse(chunksRaw),
+      _paths: p,
+    };
+  } catch (e) {
+    if (e.code === 'ENOENT') return null;
+    throw e;
+  }
+}
+
+async function saveIndex(p, manifest, chunks) {
+  await fs.mkdir(p.dir, { recursive: true });
+  await fs.writeFile(p.chunks, JSON.stringify(chunks), 'utf8');
+  await fs.writeFile(
+    p.manifest,
+    JSON.stringify({ ...manifest, chunkCount: chunks.length }, null, 2) + '\n',
+    'utf8',
+  );
+}
+
+/**
+ * 인덱스 빌드 — 파일 스캔, 청크 분할, 변경된 청크만 임베딩 후 저장.
+ *
+ * @param {object} opts
+ * @param {object} opts.effective  loadEffectiveConfig().effective
+ * @param {object} opts.contextCfg bc.config.json 의 context (include/exclude)
+ * @param {boolean} opts.rebuild   true 면 기존 임베딩 무시하고 전부 재계산
+ * @param {(s:string)=>void} opts.onProgress 진행 메시지 콜백
+ */
+export async function buildIndex({
+  effective,
+  contextCfg = {},
+  rebuild = false,
+  onProgress = () => {},
+} = {}) {
+  const p = await getIndexPaths();
+  const { projectRoot } = p;
+
+  onProgress('  파일 목록 수집 중…');
+  const files = await walkProjectFiles(projectRoot, contextCfg);
+  if (files.length === 0) {
+    return { ok: false, reason: '인덱싱할 파일이 없습니다. bc.config.json 의 context.include 를 확인하세요.' };
+  }
+  onProgress(`  파일 ${files.length}개 발견. 청크 분할 중…`);
+
+  const fileMaxBytes = 100 * 1024;
+  const allChunks = [];
+  for (const abs of files) {
+    let content;
+    try {
+      const stat = await fs.stat(abs);
+      if (stat.size > fileMaxBytes) continue; // 너무 큰 파일은 스킵
+      content = await fs.readFile(abs, 'utf8');
+    } catch {
+      continue;
+    }
+    const r = relPath(projectRoot, abs);
+    for (const c of chunkFile({ relPath: r, content })) allChunks.push(c);
+  }
+  onProgress(`  청크 ${allChunks.length}개 생성.`);
+
+  // 기존 인덱스에서 hash 일치하는 청크의 임베딩을 재사용 (증분 갱신).
+  let reused = 0;
+  let toEmbed = allChunks;
+  if (!rebuild) {
+    const existing = await loadIndex(projectRoot);
+    if (existing && existing.embeddingModel === DEFAULT_EMBED_MODEL) {
+      const byHash = new Map(existing.chunks.map((c) => [c.hash, c.embedding]));
+      toEmbed = [];
+      for (const c of allChunks) {
+        const cached = byHash.get(c.hash);
+        if (cached) {
+          c.embedding = cached;
+          reused++;
+        } else {
+          toEmbed.push(c);
+        }
+      }
+      onProgress(`  ${reused}개 재사용, ${toEmbed.length}개 신규 임베딩 필요.`);
+    }
+  }
+
+  if (toEmbed.length > 0) {
+    onProgress(`  OpenAI 임베딩 중… (model=${DEFAULT_EMBED_MODEL})`);
+    const { makeEmbeddingModel } = await import('./embed.js');
+    const model = makeEmbeddingModel(effective);
+    const embedded = await embedChunks(model, toEmbed, {
+      onBatch: ({ done, total }) => onProgress(`    배치 진행: ${done}/${total}`),
+    });
+    // 새로 임베딩된 청크를 allChunks 에 반영 (hash 일치하는 자리로 머지).
+    const newByHash = new Map(embedded.map((e) => [e.hash, e.embedding]));
+    for (const c of allChunks) {
+      if (!c.embedding) c.embedding = newByHash.get(c.hash);
+    }
+  }
+
+  const manifest = {
+    version: INDEX_VERSION,
+    embeddingModel: DEFAULT_EMBED_MODEL,
+    builtAt: new Date().toISOString(),
+    fileCount: files.length,
+    reused,
+    newlyEmbedded: toEmbed.length - reused < 0 ? toEmbed.length : toEmbed.length,
+  };
+  await saveIndex(p, manifest, allChunks);
+  return { ok: true, manifest, paths: p };
+}

package/src/indexer/walker.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+
+import fg from 'fast-glob';
+
+/**
+ * bc.config.json 의 context.include / context.exclude 글롭을 따라
+ * 인덱싱 대상 파일 절대경로 목록을 돌려준다.
+ *
+ * - 항상 node_modules / .bc / .git / dist / build / .next 는 제외
+ * - 100KB 넘는 파일은 인덱싱하지 않는다 (대부분 minified/generated)
+ */
+export async function walkProjectFiles(projectRoot, contextCfg = {}) {
+  const include =
+    contextCfg.include?.length
+      ? contextCfg.include
+      : ['src/**/*.{ts,tsx,js,jsx}', 'app/**/*.{ts,tsx,js,jsx}', 'bc.config.json'];
+
+  const baseExclude = [
+    '**/node_modules/**',
+    '**/.bc/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/.expo/**',
+    '**/coverage/**',
+  ];
+  const userExclude = contextCfg.exclude ?? [];
+
+  const matches = await fg(include, {
+    cwd: projectRoot,
+    absolute: true,
+    onlyFiles: true,
+    ignore: [...baseExclude, ...userExclude],
+    dot: false,
+    suppressErrors: true,
+  });
+
+  // 중복 제거 (include 글롭이 겹칠 수 있음).
+  return Array.from(new Set(matches));
+}
+
+export function relPath(projectRoot, abs) {
+  return path.relative(projectRoot, abs).split(path.sep).join('/');
+}

package/src/openapi/cache.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+import { findProjectConfigPath } from '../config/index.js';
+import { loadOpenApi } from './fetch.js';
+
+const TTL_MS = 60 * 60 * 1000; // 1시간
+
+async function getCacheDir(cwd = process.cwd()) {
+  const projectConfig = await findProjectConfigPath(cwd);
+  const root = projectConfig ? path.dirname(projectConfig) : cwd;
+  return path.join(root, '.bc', 'cache');
+}
+
+function keyFor(input) {
+  return crypto.createHash('sha1').update(String(input)).digest('hex').slice(0, 12);
+}
+
+/**
+ * URL 캐시가 있으면 그걸로, 없거나 만료되었으면 fetch 후 갱신.
+ * 결과는 { doc, cached, source } 형태.
+ *
+ * - 네트워크 실패 시: 만료된 캐시라도 있으면 그걸로 폴백 (offline-friendly).
+ * - 캐시는 .bc/cache/openapi-<hash>.json 에 저장.
+ */
+export async function getCachedOpenApi(input) {
+  const dir = await getCacheDir();
+  const file = path.join(dir, `openapi-${keyFor(input)}.json`);
+
+  let cached = null;
+  let cachedFresh = false;
+  try {
+    const stat = await fs.stat(file);
+    const raw = await fs.readFile(file, 'utf8');
+    cached = JSON.parse(raw);
+    cachedFresh = Date.now() - stat.mtimeMs < TTL_MS;
+  } catch {
+    /* miss */
+  }
+
+  if (cachedFresh && cached) {
+    return { doc: cached, cached: true, source: input };
+  }
+
+  try {
+    const { doc } = await loadOpenApi(input);
+    if (doc) {
+      await fs.mkdir(dir, { recursive: true });
+      await fs.writeFile(file, JSON.stringify(doc), 'utf8');
+      return { doc, cached: false, source: input };
+    }
+    // doc 가 null (YAML) — 캐시 못 쓰지만 fetch 자체는 성공한 케이스
+    return { doc: null, cached: false, source: input };
+  } catch (err) {
+    // 네트워크/파싱 실패 — 만료된 캐시라도 있으면 그걸 돌려준다.
+    if (cached) return { doc: cached, cached: true, source: input, stale: true };
+    throw err;
+  }
+}

package/src/openapi/codegen.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import openapiTS, { astToString } from 'openapi-typescript';
+
+const FILE_HEADER = `// AUTO-GENERATED by \`bc gen api-types\`
+// Do not edit manually. Re-run \`bc gen api-types\` to refresh.
+//
+// Source: __SOURCE__
+// Generated: __DATE__
+
+`;
+
+/**
+ * OpenAPI 입력으로부터 TypeScript 타입 파일을 생성해 디스크에 쓴다.
+ *
+ * @param {object} args
+ * @param {string|object} args.input  URL / 파일 경로 / 이미 파싱된 OpenAPI 객체
+ * @param {string} args.outFile       절대/상대 경로
+ * @param {string} args.sourceLabel   파일 헤더 주석에 표기할 출처 문자열
+ * @returns {{ outFile: string, bytes: number }}
+ */
+export async function generateApiTypes({ input, outFile, sourceLabel }) {
+  // openapi-typescript v7: 입력은 URL 객체, 파싱된 객체, 또는 path 문자열을 받음.
+  // 우리가 받은 input 이 URL 문자열이면 URL 인스턴스로, 파일 경로면 그대로 넘김.
+  let sdkInput = input;
+  if (typeof input === 'string' && /^https?:\/\//.test(input)) {
+    sdkInput = new URL(input);
+  } else if (typeof input === 'string') {
+    sdkInput = path.resolve(input);
+  }
+
+  const ast = await openapiTS(sdkInput);
+  const code = astToString(ast);
+
+  const header = FILE_HEADER
+    .replace('__SOURCE__', sourceLabel ?? String(input))
+    .replace('__DATE__', new Date().toISOString());
+
+  const final = header + code + (code.endsWith('\n') ? '' : '\n');
+
+  await fs.mkdir(path.dirname(outFile), { recursive: true });
+  await fs.writeFile(outFile, final, 'utf8');
+  return { outFile, bytes: Buffer.byteLength(final, 'utf8') };
+}

package/src/openapi/fetch.js

@@ -0,0 +1,69 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * OpenAPI 스펙을 URL/파일경로/JSON객체 중 무엇으로 받든 정상화해서
+ * `{ source, doc }` 로 돌려준다.
+ *
+ * - URL  ('http://' / 'https://') → fetch 후 파싱
+ * - 파일 경로 (.json / .yaml / .yml) → 디스크에서 읽기
+ *   - YAML 은 openapi-typescript 에 그대로 넘겨도 되지만, 우리가 endpoint 요약을
+ *     뽑을 땐 JSON 객체가 필요해서 yaml 파서가 필요함. 의존성 키우지 않도록
+ *     YAML 인 경우 doc 필드는 null 로 두고 source(원본 문자열)만 반환한다.
+ * - 그 외 → 에러
+ *
+ * 반환된 source 는 openapi-typescript 의 입력으로 그대로 쓸 수 있다.
+ */
+export async function loadOpenApi(input) {
+  if (!input) {
+    const e = new Error('OpenAPI 입력이 비어있습니다 (URL 또는 파일 경로 필요).');
+    e.code = 'BC_NO_OPENAPI_INPUT';
+    throw e;
+  }
+
+  // URL?
+  if (/^https?:\/\//.test(input)) {
+    const res = await fetch(input);
+    if (!res.ok) {
+      const e = new Error(`OpenAPI fetch 실패: ${res.status} ${res.statusText} (${input})`);
+      e.code = 'BC_OPENAPI_FETCH_FAILED';
+      throw e;
+    }
+    const text = await res.text();
+    let doc = null;
+    try {
+      doc = JSON.parse(text);
+    } catch {
+      // 서버가 YAML 을 줄 수도 있다 — 객체 추출은 포기하지만 source(URL) 는 그대로.
+    }
+    return { source: input, text, doc };
+  }
+
+  // 로컬 파일?
+  const abs = path.resolve(input);
+  let stat;
+  try {
+    stat = await fs.stat(abs);
+  } catch {
+    const e = new Error(`OpenAPI 파일을 찾을 수 없습니다: ${input}`);
+    e.code = 'BC_OPENAPI_FILE_NOT_FOUND';
+    throw e;
+  }
+  if (!stat.isFile()) {
+    const e = new Error(`OpenAPI 경로가 파일이 아닙니다: ${input}`);
+    e.code = 'BC_OPENAPI_NOT_A_FILE';
+    throw e;
+  }
+  const text = await fs.readFile(abs, 'utf8');
+  let doc = null;
+  if (abs.endsWith('.json')) {
+    try {
+      doc = JSON.parse(text);
+    } catch (err) {
+      const e = new Error(`JSON 파싱 실패: ${err.message}`);
+      e.code = 'BC_OPENAPI_PARSE_FAILED';
+      throw e;
+    }
+  }
+  return { source: abs, text, doc };
+}

package/src/openapi/summary.js

@@ -0,0 +1,75 @@
+/**
+ * 파싱된 OpenAPI 객체를 → 모델에 주입할 "압축 요약" 텍스트로 변환.
+ *
+ * 목표: 토큰 폭발 방지하면서도 모델이 "이 API 스펙이 있구나, 어떤 엔드포인트가
+ * 있구나" 를 알게 하는 정도. 자세한 스키마는 RAG 가 types.gen.ts 통해서 별도로
+ * 가져오게 함.
+ *
+ * 결과 형태 (예):
+ *   API: Petstore v3.0
+ *   base: /api/v3
+ *   endpoints:
+ *     GET    /pet/{petId}        Find pet by ID
+ *     POST   /pet                 Add a new pet to the store
+ *     ...
+ */
+const METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+const MAX_ENDPOINTS = 200;
+const MAX_BYTES = 8 * 1024;
+
+export function summarizeOpenApi(doc) {
+  if (!doc || typeof doc !== 'object') return null;
+
+  const lines = [];
+  const title = doc.info?.title ?? '(untitled)';
+  const version = doc.info?.version ?? '';
+  lines.push(`API: ${title}${version ? ' v' + version : ''}`);
+
+  const servers = (doc.servers ?? []).map((s) => s.url).filter(Boolean);
+  if (servers.length) {
+    lines.push(`base: ${servers.slice(0, 3).join(', ')}`);
+  }
+
+  const endpoints = [];
+  for (const [pathStr, methods] of Object.entries(doc.paths ?? {})) {
+    if (!methods || typeof methods !== 'object') continue;
+    for (const m of METHODS) {
+      const op = methods[m];
+      if (!op || typeof op !== 'object') continue;
+      const desc = op.summary || op.operationId || op.description || '';
+      endpoints.push({
+        method: m.toUpperCase(),
+        path: pathStr,
+        desc: desc.split('\n')[0].slice(0, 90),
+      });
+    }
+  }
+
+  // 너무 많으면 자른다 — 모델이 알아야 하는 건 "어떤 종류의 엔드포인트가 있다" 정도면 충분.
+  const total = endpoints.length;
+  const shown = endpoints.slice(0, MAX_ENDPOINTS);
+
+  lines.push(`endpoints: (${shown.length}/${total})`);
+  for (const e of shown) {
+    lines.push(`  ${e.method.padEnd(6)} ${e.path}${e.desc ? '  -- ' + e.desc : ''}`);
+  }
+  if (shown.length < total) {
+    lines.push(`  ... and ${total - shown.length} more`);
+  }
+
+  let result = lines.join('\n');
+  if (Buffer.byteLength(result, 'utf8') > MAX_BYTES) {
+    // 안전 장치 — desc 다 자르고 다시.
+    const compact = [
+      lines[0],
+      servers.length ? lines[1] : null,
+      `endpoints: (${shown.length}/${total})`,
+      ...shown.map((e) => `  ${e.method.padEnd(6)} ${e.path}`),
+      shown.length < total ? `  ... and ${total - shown.length} more` : null,
+    ]
+      .filter(Boolean)
+      .join('\n');
+    result = compact;
+  }
+  return result;
+}

package/src/prompts/initPrompts.js

@@ -1,5 +1,7 @@
 import inquirer from 'inquirer';
 
+import { modelChoices, DEFAULT_MODEL_ID } from '../ai/models.js';
+
 export async function askInitQuestions() {
   return inquirer.prompt([
     {
@@ -22,5 +24,27 @@ export async function askInitQuestions() {
         { name: 'Next.js  (App Router + TypeScript)', value: 'next' },
       ],
     },
+    {
+      type: 'list',
+      name: 'aiModel',
+      message: 'bc chat 에서 기본으로 쓸 AI 모델은?',
+      choices: [
+        ...modelChoices(),
+        { name: '나중에 설정 (bc config set-model)', value: null },
+      ],
+      default: DEFAULT_MODEL_ID,
+    },
+    {
+      type: 'input',
+      name: 'figmaUrl',
+      message: 'Figma 파일 URL (선택, 엔터로 건너뛰기):',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'openapiUrl',
+      message: '백엔드 OpenAPI(Swagger) URL (선택, 엔터로 건너뛰기):',
+      default: '',
+    },
   ]);
 }