triflux 10.0.0 → 10.0.2

package/scripts/lib/skill-template.mjs

@@ -0,0 +1,326 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
+
+const IF_TAG_RE = /{{\s*(#if\s+([A-Za-z0-9_.-]+)|\/if)\s*}}/g;
+const PARTIAL_RE = /{{>\s*([A-Za-z0-9_./-]+)\s*}}/g;
+const FILE_INCLUDE_RE = /{{#include\s+([A-Za-z0-9_./-]+)\s*}}/g;
+const VARIABLE_RE = /{{\s*([A-Za-z0-9_.-]+)\s*}}/g;
+const FRONTMATTER_RE = /^---\r?\n(?:([\s\S]*?)\r?\n)?---\r?\n?/;
+
+function isTruthy(value) {
+  if (typeof value === "string") return value.trim().length > 0;
+  return Boolean(value);
+}
+
+function normalizeVariable(context, key) {
+  if (Object.prototype.hasOwnProperty.call(context, key)) return context[key];
+  const upper = key.toUpperCase();
+  if (Object.prototype.hasOwnProperty.call(context, upper)) return context[upper];
+  return undefined;
+}
+
+function parseBoolean(raw) {
+  if (typeof raw !== "string") return undefined;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  return undefined;
+}
+
+function parseScalar(raw) {
+  if (raw == null) return "";
+  const value = raw.trim();
+  if (!value) return "";
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  const bool = parseBoolean(value);
+  return bool ?? value;
+}
+
+function parseMultilineValue(lines, startIndex, marker) {
+  const fold = marker.startsWith(">");
+  const chunks = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+    index += 1;
+    chunks.push(lines[index].replace(/^\s+/, ""));
+  }
+
+  return {
+    index,
+    value: fold ? chunks.join(" ").trim() : chunks.join("\n").trim(),
+  };
+}
+
+function parseListValue(lines, startIndex) {
+  const items = [];
+  let index = startIndex;
+
+  while (index + 1 < lines.length) {
+    const nextLine = lines[index + 1];
+    const match = nextLine.match(/^\s*-\s+(.*)$/);
+    if (match) {
+      index += 1;
+      items.push(parseScalar(match[1]));
+      continue;
+    }
+    if (/^\s*$/.test(nextLine)) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+
+  return { index, value: items };
+}
+
+function parseFrontmatterBlock(block) {
+  const lines = block.split(/\r?\n/);
+  const data = {};
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) continue;
+
+    const [, rawKey, rawValue] = match;
+    const key = rawKey.trim();
+    const value = rawValue.trim();
+
+    if (value === ">" || value === "|" || value === ">-" || value === "|-") {
+      const parsed = parseMultilineValue(lines, i, value);
+      data[key] = parsed.value;
+      i = parsed.index;
+      continue;
+    }
+
+    if (!value) {
+      const parsed = parseListValue(lines, i);
+      if (parsed.index !== i) {
+        data[key] = parsed.value;
+        i = parsed.index;
+        continue;
+      }
+    }
+
+    data[key] = parseScalar(value);
+  }
+
+  return data;
+}
+
+function evaluateConditionals(source, context) {
+  const matcher = new RegExp(IF_TAG_RE.source, "g");
+
+  function walk(startIndex, nested) {
+    let output = "";
+    let cursor = startIndex;
+
+    while (true) {
+      const found = matcher.exec(source);
+      if (!found) {
+        if (nested) throw new Error("Unclosed {{#if ...}} block in template");
+        output += source.slice(cursor);
+        return { output, index: source.length };
+      }
+
+      output += source.slice(cursor, found.index);
+      cursor = matcher.lastIndex;
+
+      const directive = found[1];
+      const flag = found[2];
+      if (directive.startsWith("#if")) {
+        const nestedResult = walk(cursor, true);
+        cursor = nestedResult.index;
+        matcher.lastIndex = cursor;
+        if (isTruthy(normalizeVariable(context, flag))) {
+          output += nestedResult.output;
+        }
+        continue;
+      }
+
+      if (!nested) {
+        throw new Error("Unexpected {{/if}} without matching {{#if ...}}");
+      }
+      return { output, index: cursor };
+    }
+  }
+
+  return walk(0, false).output;
+}
+
+function renderPartials(source, context, partials, options, includeStack) {
+  return source.replace(PARTIAL_RE, (_full, partialName) => {
+    const partial = partials[partialName];
+    if (partial == null) {
+      throw new Error(`Missing partial: ${partialName}`);
+    }
+    if (includeStack.includes(partialName)) {
+      const chain = [...includeStack, partialName].join(" -> ");
+      throw new Error(`Circular partial include: ${chain}`);
+    }
+    return renderWithContext(partial, context, partials, options, [
+      ...includeStack,
+      partialName,
+    ]);
+  });
+}
+
+function normalizeIncludeName(includeName) {
+  return includeName.replace(/\\/g, "/");
+}
+
+function resolveIncludeContent(includeName, options) {
+  const normalizedName = normalizeIncludeName(includeName);
+  if (Object.prototype.hasOwnProperty.call(options.includes, normalizedName)) {
+    return options.includes[normalizedName];
+  }
+  if (!options.includeBaseDir) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const baseDir = resolve(options.includeBaseDir);
+  const fullPath = resolve(baseDir, normalizedName);
+  const relativePath = relative(baseDir, fullPath);
+  const isInsideBaseDir =
+    relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
+
+  if (!isInsideBaseDir || !existsSync(fullPath)) {
+    throw new Error(`Missing include: ${normalizedName}`);
+  }
+
+  const content = readFileSync(fullPath, "utf8");
+  options.includes[normalizedName] = content;
+  return content;
+}
+
+function renderFileIncludes(source, context, partials, options, includeStack) {
+  return source.replace(FILE_INCLUDE_RE, (_full, includeName) => {
+    const normalizedName = normalizeIncludeName(includeName);
+    const content = resolveIncludeContent(normalizedName, options);
+    if (includeStack.includes(normalizedName)) {
+      const chain = [...includeStack, normalizedName].join(" -> ");
+      throw new Error(`Circular template include: ${chain}`);
+    }
+    return renderWithContext(content, context, partials, options, [
+      ...includeStack,
+      normalizedName,
+    ]);
+  });
+}
+
+function renderVariables(source, context) {
+  return source.replace(VARIABLE_RE, (full, key) => {
+    const value = normalizeVariable(context, key);
+    if (value == null) {
+      throw new Error(`Missing template variable: ${key}`);
+    }
+    return String(value);
+  });
+}
+
+function renderWithContext(source, context, partials, options, includeStack = []) {
+  const afterIf = evaluateConditionals(source, context);
+  const afterPartials = renderPartials(afterIf, context, partials, options, includeStack);
+  const afterFileIncludes = renderFileIncludes(
+    afterPartials,
+    context,
+    partials,
+    options,
+    includeStack,
+  );
+  return renderVariables(afterFileIncludes, context);
+}
+
+function readAllTemplateFiles(rootDir, currentDir = rootDir) {
+  if (!rootDir || !existsSync(rootDir)) return [];
+
+  const entries = readdirSync(currentDir, { withFileTypes: true }).sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
+  const files = [];
+
+  for (const entry of entries) {
+    const fullPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...readAllTemplateFiles(rootDir, fullPath));
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+    if (!entry.name.endsWith(".md") && !entry.name.endsWith(".tmpl")) continue;
+
+    const relativePath = relative(rootDir, fullPath).replace(/\\/g, "/");
+    const content = readFileSync(fullPath, "utf8");
+    files.push({ fullPath, relativePath, content });
+  }
+
+  return files;
+}
+
+function setPartial(partials, key, value) {
+  if (!key) return;
+  if (!Object.prototype.hasOwnProperty.call(partials, key)) {
+    partials[key] = value;
+  }
+}
+
+export function parseFrontmatter(source) {
+  const match = source.match(FRONTMATTER_RE);
+  if (!match) return { data: {}, body: source };
+
+  const data = parseFrontmatterBlock(match[1] ?? "");
+  const body = source.slice(match[0].length);
+  return { data, body };
+}
+
+export function buildSkillTemplateContext({ frontmatter = {}, skillDirName = "" } = {}) {
+  const context = { ...frontmatter };
+  const skillName = String(frontmatter.name || skillDirName || "").trim();
+  const skillDescription = String(frontmatter.description || "").trim();
+
+  let deep = frontmatter.DEEP ?? frontmatter.deep;
+  if (typeof deep === "string") {
+    const parsed = parseBoolean(deep.trim().toLowerCase());
+    deep = parsed ?? deep;
+  }
+  if (typeof deep !== "boolean") {
+    deep = /(^|[-_])deep($|[-_])/i.test(skillName);
+  }
+
+  context.SKILL_NAME = skillName;
+  context.SKILL_DESCRIPTION = skillDescription;
+  context.DEEP = deep;
+  return context;
+}
+
+export function loadTemplatePartials(partialsDir) {
+  const files = readAllTemplateFiles(partialsDir);
+  const partials = {};
+
+  for (const file of files) {
+    const extension = extname(file.relativePath);
+    const withoutExt = extension
+      ? file.relativePath.slice(0, -extension.length)
+      : file.relativePath;
+    const normalized = withoutExt.replace(/\\/g, "/");
+    const base = basename(normalized);
+
+    setPartial(partials, normalized, file.content);
+    setPartial(partials, base, file.content);
+  }
+
+  return partials;
+}
+
+export function renderSkillTemplate(template, context = {}, options = {}) {
+  const { partials = {}, includes = {}, includeBaseDir = "" } = options;
+  return renderWithContext(template, context, partials, {
+    includeBaseDir,
+    includes: { ...includes },
+  });
+}

package/scripts/mcp-check.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+// MCP inventory cache for dynamic MCP filtering.
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { MCP_SERVER_TOOL_CATALOG, normalizeServerMetadata } from './lib/mcp-server-catalog.mjs';
+
+const CACHE_DIR = join(homedir(), '.claude', 'cache');
+const CACHE_FILE = join(CACHE_DIR, 'mcp-inventory.json');
+
+function countConfiguredTools(config = {}, fallbackToolCount = 0) {
+  const directKeys = ['tools', 'toolNames', 'allowedTools', 'includeTools'];
+  for (const key of directKeys) {
+    if (Array.isArray(config[key])) return config[key].length;
+  }
+
+  if (Array.isArray(config.excludeTools)) {
+    return Math.max(0, fallbackToolCount - config.excludeTools.length);
+  }
+
+  return fallbackToolCount;
+}
+
+export function createServerRecord(name, status, config = {}) {
+  const normalizedName = typeof name === 'string' ? name.trim() : '';
+  const fallback = normalizeServerMetadata(normalizedName, {});
+  const toolCount = countConfiguredTools(config, fallback.tool_count);
+  const domainTags = Array.isArray(config.domain_tags)
+    ? config.domain_tags
+    : Array.isArray(config.domainTags)
+      ? config.domainTags
+      : [];
+
+  const metadata = normalizeServerMetadata(normalizedName, {
+    ...config,
+    tool_count: toolCount,
+    domain_tags: domainTags,
+  });
+
+  return {
+    name: normalizedName,
+    status,
+    tool_count: metadata.tool_count,
+    domain_tags: metadata.domain_tags,
+  };
+}
+
+export function getCodexMcp() {
+  try {
+    const output = execSync('codex mcp list', {
+      encoding: 'utf8',
+      timeout: 15000,
+      stdio: ['pipe', 'pipe', 'ignore'],
+      windowsHide: true,
+    });
+    const lines = output.trim().split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length < 2) return [];
+
+    const servers = [];
+    for (let i = 1; i < lines.length; i += 1) {
+      const cols = lines[i].split(/\s{2,}/);
+      if (cols.length < 2) continue;
+
+      const name = cols[0].trim();
+      const statusMatch = lines[i].match(/\b(enabled|disabled)\b/i);
+      const status = statusMatch ? statusMatch[1].toLowerCase() : 'unknown';
+      if (!name || name.startsWith('-')) continue;
+      servers.push(createServerRecord(name, status));
+    }
+    return servers;
+  } catch {
+    return null;
+  }
+}
+
+export function getGeminiMcp() {
+  try {
+    const settingsPath = join(homedir(), '.gemini', 'settings.json');
+    if (!existsSync(settingsPath)) return null;
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const mcpServers = settings.mcpServers || {};
+    return Object.entries(mcpServers).map(([name, config]) => createServerRecord(name, 'configured', config || {}));
+  } catch {
+    return null;
+  }
+}
+
+// ── Claude MCP 서버 발견 ──
+
+const CLAUDE_DIR = join(homedir(), '.claude');
+
+// Anthropic 클라우드 호스팅 MCP 서버 — Claude Code 런타임에서 항상 가용.
+// mcp-server-catalog.mjs의 MCP_SERVER_TOOL_CATALOG에 정의된 서버 중
+// 로컬 설치가 불필요한 클라우드 제공 서버.
+const WELL_KNOWN_CLOUD_SERVERS = Object.freeze([
+  'brave-search',
+  'exa',
+  'context7',
+]);
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function extractMcpServerNames(mcpJsonPath) {
+  const data = readJsonSafe(mcpJsonPath);
+  if (!data?.mcpServers || typeof data.mcpServers !== 'object') return [];
+  return Object.entries(data.mcpServers)
+    .filter(([name]) => typeof name === 'string' && name.trim())
+    .map(([name, config]) => ({ name: name.trim(), config: config || {} }));
+}
+
+function walkUpForMcpJson(startDir, maxDepth = 5) {
+  const found = [];
+  let dir = resolve(startDir);
+  for (let i = 0; i < maxDepth; i += 1) {
+    const candidate = join(dir, '.mcp.json');
+    if (existsSync(candidate)) found.push(candidate);
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return found;
+}
+
+function scanPluginsMcpJson() {
+  const pluginsDir = join(CLAUDE_DIR, 'plugins');
+  if (!existsSync(pluginsDir)) return [];
+  const found = [];
+  const walk = (dir, depth = 0) => {
+    if (depth > 4) return;
+    try {
+      for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        const full = join(dir, entry.name);
+        if (entry.isFile() && entry.name === '.mcp.json') {
+          found.push(full);
+        } else if (entry.isDirectory()) {
+          walk(full, depth + 1);
+        }
+      }
+    } catch { /* permission errors */ }
+  };
+  walk(pluginsDir);
+  return found;
+}
+
+export function getClaudeMcp(cwd = process.cwd()) {
+  const serverMap = new Map();
+
+  // 1) .mcp.json 파일 트리 스캔 (CWD → root)
+  for (const mcpJson of walkUpForMcpJson(cwd)) {
+    for (const { name, config } of extractMcpServerNames(mcpJson)) {
+      if (!serverMap.has(name)) {
+        serverMap.set(name, createServerRecord(name, 'configured', config));
+      }
+    }
+  }
+
+  // 2) ~/.claude/plugins/ 스캔
+  for (const mcpJson of scanPluginsMcpJson()) {
+    for (const { name, config } of extractMcpServerNames(mcpJson)) {
+      if (!serverMap.has(name)) {
+        serverMap.set(name, createServerRecord(name, 'configured', config));
+      }
+    }
+  }
+
+  // 3) ~/.claude/settings.json + settings.local.json의 mcpServers
+  for (const settingsFile of ['settings.json', 'settings.local.json']) {
+    const data = readJsonSafe(join(CLAUDE_DIR, settingsFile));
+    if (!data?.mcpServers) continue;
+    for (const [name, config] of Object.entries(data.mcpServers)) {
+      if (typeof name !== 'string' || !name.trim()) continue;
+      if (!serverMap.has(name.trim())) {
+        serverMap.set(name.trim(), createServerRecord(name.trim(), 'configured', config || {}));
+      }
+    }
+  }
+
+  // 4) Well-known Anthropic 클라우드 MCP 서버 (카탈로그에 정의된 것만)
+  for (const name of WELL_KNOWN_CLOUD_SERVERS) {
+    if (serverMap.has(name)) continue;
+    if (!MCP_SERVER_TOOL_CATALOG[name]) continue;
+    serverMap.set(name, createServerRecord(name, 'available'));
+  }
+
+  return [...serverMap.values()];
+}
+
+export function buildInventory(cwd = process.cwd()) {
+  const inventory = {
+    timestamp: new Date().toISOString(),
+    codex: { available: false, servers: [] },
+    gemini: { available: false, servers: [] },
+    claude: { available: true, servers: [] },
+  };
+
+  const codexServers = getCodexMcp();
+  if (codexServers !== null) {
+    inventory.codex.available = true;
+    inventory.codex.servers = codexServers;
+  }
+
+  const geminiServers = getGeminiMcp();
+  if (geminiServers !== null) {
+    inventory.gemini.available = true;
+    inventory.gemini.servers = geminiServers;
+  }
+
+  inventory.claude.servers = getClaudeMcp(cwd);
+
+  return inventory;
+}
+
+export function writeInventoryCache(inventory = buildInventory()) {
+  if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+  writeFileSync(CACHE_FILE, JSON.stringify(inventory, null, 2));
+  return inventory;
+}
+
+export function main() {
+  writeInventoryCache();
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main();
+}

package/scripts/mcp-cleanup.ps1

@@ -0,0 +1,17 @@
+# mcp-cleanup.ps1 — Claude Code Stop hook: MCP 고아 프로세스 정리
+# Windows에서 Claude Code 세션 종료 시 남는 MCP 서버 고아 프로세스를 정리한다.
+# 원인: Claude Code가 stdio MCP 자식 프로세스 트리를 Windows에서 제대로 kill하지 못함
+#       (GitHub Issues #1935, #15211, #28126)
+$ErrorActionPreference = 'SilentlyContinue'
+
+# npx MCP servers (brave, notion, context7, exa, tavily, jira, playwright, etc.)
+# + oh-my-codex MCP servers (team/code-intel/memory/trace/state)
+# + omc bridge
+Get-CimInstance Win32_Process -Filter "Name='node.exe' OR Name='cmd.exe'" |
+  Where-Object { $_.CommandLine -match 'npx-cli|oh-my-codex[\\/]dist[\\/]mcp|omc.*bridge.*mcp-server' } |
+  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }
+
+# serena (uvx) + python MCP orphans
+Get-CimInstance Win32_Process -Filter "Name='python.exe' OR Name='uvx.exe'" |
+  Where-Object { $_.CommandLine -match 'serena|uv[\\/](cache|python)' } |
+  ForEach-Object { taskkill /F /PID $_.ProcessId 2>$null }