workq-mcp 0.1.0 → 0.1.2

package/lib/natural-git.mjs

@@ -0,0 +1,481 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const IGNORE_DIRS = new Set([
+  ".git",
+  ".next",
+  ".turbo",
+  ".workq",
+  ".gstack",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "output",
+  "playwright-report",
+  "test-results"
+]);
+
+const TEXT_EXTENSIONS = new Set([
+  ".bash",
+  ".c",
+  ".cc",
+  ".cjs",
+  ".cpp",
+  ".cs",
+  ".css",
+  ".go",
+  ".h",
+  ".hpp",
+  ".html",
+  ".java",
+  ".js",
+  ".json",
+  ".jsx",
+  ".kt",
+  ".mjs",
+  ".php",
+  ".py",
+  ".rb",
+  ".rs",
+  ".sh",
+  ".sql",
+  ".swift",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".xml",
+  ".yaml",
+  ".yml"
+]);
+
+const SECRET_LINE = /(api[_-]?key|secret|token|password|passwd|github_pat|ghp_|sk-[a-z0-9])/i;
+const MAX_FILE_BYTES = 420_000;
+const MAX_FILES = 700;
+
+function normalizePath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+
+function safeRead(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return "";
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function shouldIgnoreDirectory(name) {
+  return IGNORE_DIRS.has(name) || /^\.workq[-_]/.test(name);
+}
+
+function walkRepository(rootDir) {
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length && files.length < MAX_FILES) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => b.name.localeCompare(a.name));
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      const relativePath = normalizePath(path.relative(rootDir, fullPath));
+      if (entry.isDirectory()) {
+        if (!shouldIgnoreDirectory(entry.name)) stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const extension = path.extname(entry.name).toLowerCase();
+      if (!TEXT_EXTENSIONS.has(extension)) continue;
+      files.push(relativePath);
+      if (files.length >= MAX_FILES) break;
+    }
+  }
+  return files.sort();
+}
+
+function languageForExtension(extension) {
+  const map = {
+    ".bash": "Shell",
+    ".c": "C",
+    ".cc": "C++",
+    ".cjs": "CommonJS",
+    ".cpp": "C++",
+    ".cs": "C#",
+    ".css": "CSS",
+    ".go": "Go",
+    ".h": "C/C++ header",
+    ".hpp": "C++ header",
+    ".html": "HTML",
+    ".java": "Java",
+    ".js": "JavaScript",
+    ".json": "JSON",
+    ".jsx": "React JSX",
+    ".kt": "Kotlin",
+    ".mjs": "JavaScript module",
+    ".php": "PHP",
+    ".py": "Python",
+    ".rb": "Ruby",
+    ".rs": "Rust",
+    ".sh": "Shell",
+    ".sql": "SQL",
+    ".swift": "Swift",
+    ".toml": "TOML",
+    ".ts": "TypeScript",
+    ".tsx": "React TSX",
+    ".xml": "XML",
+    ".yaml": "YAML",
+    ".yml": "YAML"
+  };
+  return map[extension] ?? extension.replace(".", "").toUpperCase();
+}
+
+function docPathForSource(sourcePath) {
+  return `natural-git/code/${sourcePath.replace(/\//g, "__")}.md`;
+}
+
+function cleanLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || SECRET_LINE.test(trimmed)) return "";
+  return trimmed;
+}
+
+function compact(value, maxLength = 220) {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 3).trim()}...`;
+}
+
+function unique(values, limit = 40) {
+  return Array.from(new Set(values.filter(Boolean))).slice(0, limit);
+}
+
+const NATURAL_SPEC_FORMAT_COMMENT = "<!-- workq-natural-spec-format: feature-v2 -->";
+
+function stripTags(value) {
+  return value.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function extractVisibleTexts(file) {
+  const texts = [];
+  const markupContent = file.content.replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "");
+  if (file.extension === ".html") {
+    for (const match of file.content.matchAll(/<title[^>]*>([\s\S]*?)<\/title>/gi)) texts.push(stripTags(match[1]));
+    for (const match of markupContent.matchAll(/>([^<>{}][^<>{}]{1,80})</g)) texts.push(stripTags(match[1]));
+  }
+  for (const match of file.content.matchAll(/\b(?:textContent|innerText|placeholder|aria-label|title)\s*=\s*["'`]([^"'`]{1,100})["'`]/g)) {
+    texts.push(stripTags(match[1]));
+  }
+  for (const match of file.content.matchAll(/<button[^>]*>([\s\S]{1,160}?)<\/button>/gi)) {
+    texts.push(stripTags(match[1]));
+  }
+  return unique(texts.map((item) => compact(item, 100)).filter((item) => item && !/^[{}()[\];,.]+$/.test(item)), 18);
+}
+
+function extractDesignFacts(file) {
+  if (![".css", ".html", ".tsx", ".jsx"].includes(file.extension)) return [];
+  const facts = [];
+  const colors = unique(Array.from(file.content.matchAll(/#[0-9a-fA-F]{3,8}|rgba?\([^)]+\)|hsla?\([^)]+\)/g)).map((match) => match[0]), 10);
+  const gradients = unique(Array.from(file.content.matchAll(/linear-gradient\([^)]+\)/g)).map((match) => match[0]), 6);
+  const radii = unique(Array.from(file.content.matchAll(/border-radius\s*:\s*([^;]+);/g)).map((match) => match[1].trim()), 6);
+  const shadows = unique(Array.from(file.content.matchAll(/box-shadow\s*:\s*([^;]+);/g)).map((match) => match[1].trim()), 6);
+  const layout = [];
+  if (/display\s*:\s*grid/.test(file.content)) layout.push("grid");
+  if (/display\s*:\s*flex/.test(file.content)) layout.push("flex");
+  if (/min-height\s*:\s*100vh/.test(file.content)) layout.push("full viewport height");
+  if (/justify-content\s*:\s*center|align-items\s*:\s*center/.test(file.content)) layout.push("centered alignment");
+  if (colors.length) facts.push(`색상 팔레트는 ${colors.join(", ")} 값을 포함한다.`);
+  if (gradients.length) facts.push(`그라데이션 배경/강조는 ${gradients.join(", ")} 형태를 사용한다.`);
+  if (layout.length) facts.push(`레이아웃은 ${unique(layout).join(", ")} 배치를 사용한다.`);
+  if (radii.length) facts.push(`둥근 모서리 값은 ${radii.join(", ")} 등이 관찰된다.`);
+  if (shadows.length) facts.push(`그림자 표현은 ${shadows.slice(0, 3).join(", ")} 값을 사용한다.`);
+  if (/@keyframes\s+([A-Za-z0-9_-]+)/.test(file.content)) {
+    facts.push(`애니메이션은 ${unique(Array.from(file.content.matchAll(/@keyframes\s+([A-Za-z0-9_-]+)/g)).map((match) => match[1])).join(", ")} keyframes를 사용한다.`);
+  }
+  return facts;
+}
+
+function extractDataModelFacts(file) {
+  const facts = [];
+  const schemaMatch = file.content.match(/new\s+mongoose\.Schema\s*\(\s*\{([\s\S]*?)\}\s*\)/m);
+  if (schemaMatch) {
+    const fields = [];
+    for (const match of schemaMatch[1].matchAll(/^\s*([A-Za-z_$][\w$]*)\s*:\s*([^,\n]+)/gm)) {
+      fields.push(`${match[1]}(${compact(match[2], 80)})`);
+    }
+    facts.push(fields.length ? `이 파일은 데이터 모델 스키마를 정의하며 필드는 ${fields.join(", ")} 이다.` : "이 파일은 데이터 모델 스키마를 정의한다.");
+  }
+  if (file.path === "package.json") {
+    const packageDoc = packageJsonDoc(file.content).split(/\r?\n/).filter((line) => line.startsWith("- `") || line.startsWith("- 패키지 이름"));
+    facts.push(...packageDoc.slice(0, 12));
+  }
+  return facts;
+}
+
+function extractEnvironmentFacts(file) {
+  const envVars = unique(
+    Array.from(file.content.matchAll(/process\.env(?:\.([A-Za-z_][A-Za-z0-9_]*)|\[["'`]([^"'`]+)["'`]\])/g)).map((match) => match[1] || match[2]),
+    18
+  );
+  const facts = [];
+  if (!envVars.length && !/get(DataDir|DbDir|WorkDir|AppUrl)|isMcpConfigured|getMiniAiConfig|isGithubCrudConfigured|requireEnv/.test(file.content)) return facts;
+  if (envVars.length) facts.push(`환경 변수 ${envVars.map((item) => `\`${item}\``).join(", ")} 값을 읽어 런타임 설정을 결정한다.`);
+  if (/getDataDir|getDbDir|getWorkDir/.test(file.content)) facts.push("데이터 저장 위치, SQLite DB 위치, 작업 파일 위치를 환경 변수와 기본값으로 분리한다.");
+  if (/getAppUrl/.test(file.content)) facts.push("앱 외부 URL은 환경 변수로 지정하고, 없으면 로컬 개발 URL을 기본값으로 사용한다.");
+  if (/isMcpConfigured|WORKQ_MCP_TOKEN/.test(file.content)) facts.push("MCP 토큰 설정 여부를 판단해 로컬 에이전트 연결 가능 상태를 구분한다.");
+  if (/getMiniAiConfig|isMiniAiConfigured|WORKQ_MINI_AI/.test(file.content)) facts.push("Mini AI endpoint, model, API key 설정을 하나의 구성값으로 묶어 triage 사용 가능 여부를 판단한다.");
+  if (/isGithubCrudConfigured|WORKQ_GITHUB_TOKEN/.test(file.content)) facts.push("GitHub CRUD token 존재 여부로 GitHub 작업 자동화 가능성을 판단한다.");
+  if (/requireEnv/.test(file.content)) facts.push("필수 환경 변수가 없으면 조용히 진행하지 않고 명시적인 설정 오류를 발생시킨다.");
+  return unique(facts, 10);
+}
+
+function extractFunctionalFacts(file, structure) {
+  const facts = [];
+  const environmentFacts = extractEnvironmentFacts(file);
+  const visibleTexts = extractVisibleTexts(file);
+  const conditionSummaries = structure.conditions
+    .map((item) => item.expression ?? item.signature ?? "")
+    .filter((item) => item && item.length <= 180 && !/[<>]/.test(item))
+    .slice(0, 10);
+  facts.push(...environmentFacts);
+  if (visibleTexts.length) facts.push(`사용자에게 보이는 주요 문구는 ${visibleTexts.map((item) => `"${item}"`).join(", ")} 이다.`);
+  if (structure.events.length) {
+    facts.push(`사용자 이벤트는 ${structure.events.map((item) => `${item.target}의 ${item.event}`).join(", ")} 흐름을 처리한다.`);
+  }
+  if (!environmentFacts.length && structure.functions.length) {
+    facts.push(`내부 동작 단위는 ${structure.functions.slice(0, 8).map((item) => `${item.name}()`).join(", ")} 등이며, 세부 구현 근거는 코드 근거 섹션에서 추적한다.`);
+  }
+  if (structure.routes.length) {
+    facts.push(`네트워크/라우트 흐름은 ${structure.routes.slice(0, 8).map((item) => `${item.kind} ${item.expression}`).join(", ")} 로 연결된다.`);
+  }
+  if (!environmentFacts.length && conditionSummaries.length) {
+    facts.push(`분기와 반복은 ${conditionSummaries.join("; ")} 조건을 기준으로 동작한다.`);
+  }
+  if (/\bfor\s*\(\s*let\s+([A-Za-z_$][\w$]*)\s*=\s*(\d+)\s*;\s*\1\s*<=\s*(\d+)/.test(file.content)) {
+    const loop = file.content.match(/\bfor\s*\(\s*let\s+([A-Za-z_$][\w$]*)\s*=\s*(\d+)\s*;\s*\1\s*<=\s*(\d+)/);
+    facts.push(`반복문은 ${loop[2]}부터 ${loop[3]}까지의 선택지 또는 결과 행을 자동 생성한다.`);
+  }
+  if (/document\.createElement\(["']button["']\)/.test(file.content)) facts.push("버튼 요소를 코드에서 자동 생성한다.");
+  if (/classList\.add\(["']active["']\)|classList\.remove\(["']active["']\)/.test(file.content)) facts.push("선택 상태는 active 클래스로 표시하고 이전 선택은 해제한다.");
+  if (/innerHTML\s*=/.test(file.content)) facts.push("사용자 선택 이후 결과 영역의 HTML을 새 내용으로 교체한다.");
+  return facts;
+}
+
+function buildVerificationFacts(file, structure) {
+  const facts = [];
+  if (extractVisibleTexts(file).length) facts.push("화면에 노출되는 문구와 버튼이 의도한 사용자 흐름을 설명하는지 확인한다.");
+  if (structure.events.length) facts.push("사용자 이벤트 실행 후 화면 상태와 데이터가 기대값으로 바뀌는지 확인한다.");
+  if (structure.conditions.length) facts.push("반복/조건의 경계값과 예외 흐름을 테스트한다.");
+  if (extractDataModelFacts(file).length) facts.push("저장되는 필드 이름, 타입, 필수 여부가 실제 데이터와 맞는지 확인한다.");
+  if (!facts.length) facts.push("이 파일이 제공하는 설정 또는 보조 로직이 연결된 기능에서 실제로 사용되는지 확인한다.");
+  return facts;
+}
+
+function sourceEvidenceFacts(file, structure) {
+  const evidence = [];
+  if (structure.functions.length) evidence.push(`함수/메서드: ${structure.functions.slice(0, 12).map((item) => `${item.name}(${item.line}행)`).join(", ")}`);
+  if (structure.variables.length) evidence.push(`주요 값: ${structure.variables.slice(0, 12).map((item) => `${item.name}(${item.line}행)`).join(", ")}`);
+  if (structure.events.length) evidence.push(`이벤트: ${structure.events.slice(0, 12).map((item) => `${item.event}(${item.line}행)`).join(", ")}`);
+  if (structure.selectors.length) evidence.push(`스타일 선택자: ${structure.selectors.slice(0, 12).join(", ")}`);
+  return evidence;
+}
+
+function extractStructure(lines) {
+  const functions = [];
+  const variables = [];
+  const conditions = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = cleanLine(lines[index]);
+    if (!line) continue;
+    const lineNumber = index + 1;
+    const fn = line.match(/(?:async\s+)?function\s+([A-Za-z_$][\w$]*)|def\s+([A-Za-z_][\w]*)|(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/);
+    if (fn) functions.push({ line: lineNumber, name: fn[1] || fn[2] || fn[3], signature: compact(line) });
+    const variable = line.match(/^(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/);
+    if (variable) variables.push({ line: lineNumber, name: variable[1], signature: compact(line) });
+    if (/\bif\s*\(|^if\s+|^elif\s+|\belse\s+if\s*\(|\bfor\s*\(|^for\s+|\bwhile\s*\(|^while\s+|\bcatch\s*\(|^except\s+/.test(line)) {
+      conditions.push({ line: lineNumber, signature: compact(line) });
+    }
+  }
+  return { functions, variables, conditions };
+}
+
+function packageJsonDoc(content) {
+  try {
+    const parsed = JSON.parse(content);
+    const scripts = Object.entries(parsed.scripts ?? {});
+    const deps = Object.keys(parsed.dependencies ?? {});
+    const devDeps = Object.keys(parsed.devDependencies ?? {});
+    return [
+      "## package.json 해석",
+      `- 패키지 이름: ${parsed.name ?? "정의 없음"}`,
+      scripts.length ? "### 실행 스크립트" : "",
+      ...scripts.map(([name, command]) => `- \`${name}\`: \`${command}\` 명령을 실행한다.`),
+      deps.length ? "### 런타임 의존성" : "",
+      deps.length ? `- ${deps.join(", ")}` : "",
+      devDeps.length ? "### 개발 의존성" : "",
+      devDeps.length ? `- ${devDeps.join(", ")}` : ""
+    ].filter(Boolean).join("\n");
+  } catch {
+    return "";
+  }
+}
+
+function sourceFileToDoc(file) {
+  const structure = {
+    imports: [],
+    exports: [],
+    classes: [],
+    routes: [],
+    events: [],
+    selectors: [],
+    ...extractStructure(file.lines)
+  };
+  const purpose =
+    file.path === "package.json"
+      ? "패키지 이름, 실행 스크립트, 의존성, Node 런타임 조건을 정의한다."
+      : extractEnvironmentFacts(file).length
+        ? "런타임 환경 변수와 기본값을 해석해 저장소, URL, MCP, Mini AI, GitHub 연결 상태를 결정한다."
+      : file.extension === ".css"
+        ? "화면 요소의 레이아웃, 색상, 반응형 배치, 상호작용 상태를 정의한다."
+        : file.extension === ".html"
+          ? "브라우저에 표시되는 정적 화면 구조와 연결된 스크립트/스타일 진입점을 정의한다."
+          : structure.functions.length
+            ? "함수 단위로 데이터를 계산하거나 화면/파일/네트워크 동작을 수행한다."
+            : "레포 동작을 구성하는 설정, 데이터, 또는 보조 텍스트를 제공한다.";
+  const dataModelFacts = extractDataModelFacts(file);
+  const functionalFacts = extractFunctionalFacts(file, structure);
+  const designFacts = extractDesignFacts(file);
+  const verificationFacts = buildVerificationFacts(file, structure);
+  const evidenceFacts = sourceEvidenceFacts(file, structure);
+  const coreRules = unique(
+    [
+      ...dataModelFacts,
+      ...extractEnvironmentFacts(file),
+      ...functionalFacts.filter((item) => /반복문|선택 상태|자동 생성|결과 영역|라우트|네트워크|분기/.test(item))
+    ],
+    12
+  );
+  return [
+    `# ${file.path}`,
+    NATURAL_SPEC_FORMAT_COMMENT,
+    "",
+    "## 기능 중심 자연어 명세",
+    `이 파일은 ${file.language} 파일이며, 제품 관점에서는 ${purpose}`,
+    "",
+    "## 파일 정보",
+    `- 원본 경로: \`${file.path}\``,
+    `- 언어/형식: ${file.language}`,
+    `- 총 라인 수: ${file.lines.length}`,
+    "",
+    functionalFacts.length ? "## 사용자 기능과 동작" : "",
+    ...functionalFacts.map((item) => `- ${item}`),
+    "",
+    coreRules.length ? "## 핵심 규칙" : "",
+    ...coreRules.map((item) => `- ${item}`),
+    "",
+    designFacts.length ? "## 화면과 디자인 명세" : "",
+    ...designFacts.map((item) => `- ${item}`),
+    "",
+    dataModelFacts.length && file.path !== "package.json" ? "## 데이터와 상태" : "",
+    ...(file.path !== "package.json" ? dataModelFacts.map((item) => `- ${item}`) : []),
+    "",
+    evidenceFacts.length ? "## 코드 근거" : "",
+    ...evidenceFacts.map((item) => `- ${item}`),
+    "",
+    "## 검증 관점",
+    ...verificationFacts.map((item) => `- ${item}`),
+    "- 제품 의도와 코드가 다를 수 있으므로, 코드에서 관찰된 동작은 승인된 제품 의도가 아니라 검증 근거로 취급한다.",
+    "- 리포트 분류 시 이 문서는 기능 존재, 화면 동작, 입력/출력, 핵심 규칙의 근거로 사용한다."
+  ].filter((line, index, array) => line || array[index - 1]).join("\n");
+}
+
+function overviewDoc({ projectKey, projectName, repository, root, sourceFiles }) {
+  const byLanguage = new Map();
+  for (const file of sourceFiles) byLanguage.set(file.language, (byLanguage.get(file.language) ?? 0) + 1);
+  return [
+    `# ${projectKey} 자연어 git 명세`,
+    NATURAL_SPEC_FORMAT_COMMENT,
+    "",
+    "## 의미",
+    "이 명세는 레포에 존재하는 코드 파일을 제품 기능, 사용자 동작, 입력/출력, 화면/디자인, 데이터 규칙 중심의 자연어 Markdown 문서로 해석한 것이다. Work Q v2에서는 이 자연어 문서를 기준으로 리포트와 코드 변경을 판단한다.",
+    "",
+    "## 프로젝트",
+    `- 프로젝트 키: ${projectKey}`,
+    `- 프로젝트 이름: ${projectName || projectKey}`,
+    `- 레포: ${repository ? `${repository.owner}/${repository.repo}` : "연결된 레포 없음"}`,
+    `- 로컬 분석 경로: \`${root}\``,
+    `- 분석된 코드/설정 파일: ${sourceFiles.length}개`,
+    "",
+    "## 언어별 파일 수",
+    ...Array.from(byLanguage.entries()).map(([language, count]) => `- ${language}: ${count}개`),
+    "",
+    "## 운영 규칙",
+    "- 자연어 문서는 코드에서 관찰한 제품 기능과 검증 가능한 동작을 설명한다.",
+    "- 각 코드 파일 문서는 라인별 번역이 아니라 기능, 규칙, 화면, 데이터, 검증 관점 중심으로 작성한다.",
+    "- 코드의 현재 동작이 곧 제품 의도라는 뜻은 아니다.",
+    "- 오너가 자연어 커밋으로 승인한 내용만 다음 코드 변경의 기준이 된다.",
+    "- 코드가 바뀌면 이 자연어 git 명세도 다시 분석하거나 수정해야 한다."
+  ].join("\n");
+}
+
+function indexDoc(sourceFiles) {
+  return [
+    "# 코드 파일 자연어 색인",
+    "",
+    "이 문서는 분석된 파일과 각 파일의 자연어 명세 문서를 연결한다.",
+    "",
+    ...sourceFiles.map((file) => `- \`${file.path}\` -> \`${docPathForSource(file.path)}\``)
+  ].join("\n");
+}
+
+export function generateNaturalGitDocs({ localPath, projectKey, projectName = "", repository = null }) {
+  const root = path.resolve(localPath);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    throw new Error(`Local repository path does not exist or is not a directory: ${localPath}`);
+  }
+  const relativePaths = walkRepository(root);
+  const sourceFiles = relativePaths
+    .map((relativePath) => {
+      const extension = path.extname(relativePath).toLowerCase();
+      const absolutePath = path.join(root, relativePath);
+      const content = safeRead(absolutePath);
+      if (!content.trim()) return null;
+      return {
+        path: relativePath,
+        extension,
+        language: languageForExtension(extension),
+        content,
+        lines: content.split(/\r?\n/)
+      };
+    })
+    .filter(Boolean);
+  const docs = [
+    {
+      path: "natural-git/README.md",
+      title: "자연어 git 명세 개요",
+      content: overviewDoc({ projectKey, projectName, repository, root, sourceFiles })
+    },
+    {
+      path: "natural-git/code-index.md",
+      title: "코드 파일 자연어 색인",
+      content: indexDoc(sourceFiles)
+    },
+    ...sourceFiles.map((file) => ({
+      path: docPathForSource(file.path),
+      title: file.path,
+      content: sourceFileToDoc(file)
+    }))
+  ];
+  return {
+    root,
+    files_scanned: relativePaths.length,
+    code_files: sourceFiles.length,
+    docs
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workq-mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Work Q MCP stdio bridge and local repository connection CLI.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   },
   "files": [
     "bin/",
+    "lib/",
     "README.md"
   ],
   "engines": {