claude-code-ultimate-guide-mcp 1.0.0

package/dist/chunk-2OLPHMWN.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/content.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2, join, sep } from "path";
+import { parse as parseYaml } from "yaml";
+import { fileURLToPath } from "url";
+
+// src/lib/fetcher.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
+import { resolve, dirname } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+var PACKAGE_VERSION = "1.0.0";
+var GITHUB_RAW_BASE = "https://raw.githubusercontent.com/FlorianBruniaux/claude-code-ultimate-guide/main";
+var CACHE_DIR = resolve(homedir(), ".cache", "claude-code-guide", PACKAGE_VERSION);
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function getCachePath(filePath) {
+  const hash = createHash("md5").update(filePath).digest("hex").slice(0, 8);
+  const safe = filePath.replace(/[^a-zA-Z0-9._-]/g, "_");
+  return resolve(CACHE_DIR, `${hash}_${safe}`);
+}
+function isCacheValid(cachePath) {
+  if (!existsSync(cachePath)) return false;
+  const stat = statSync(cachePath);
+  return Date.now() - stat.mtimeMs < CACHE_TTL_MS;
+}
+async function fetchFile(filePath) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const cachePath = getCachePath(normalizedPath);
+  if (isCacheValid(cachePath)) {
+    return readFileSync(cachePath, "utf8");
+  }
+  const url = `${GITHUB_RAW_BASE}/${normalizedPath}`;
+  try {
+    const response = await fetch(url, {
+      headers: { "User-Agent": "claude-code-ultimate-guide-mcp/1.0.0" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      if (existsSync(cachePath)) {
+        return readFileSync(cachePath, "utf8");
+      }
+      return null;
+    }
+    const content = await response.text();
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, content, "utf8");
+    return content;
+  } catch {
+    if (existsSync(cachePath)) {
+      return readFileSync(cachePath, "utf8");
+    }
+    return null;
+  }
+}
+
+// src/lib/content.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = resolve2(__filename, "..");
+var GUIDE_ROOT = process.env.GUIDE_ROOT ? resolve2(process.env.GUIDE_ROOT) : null;
+var CONTENT_DIR = GUIDE_ROOT ? resolve2(GUIDE_ROOT, "machine-readable") : resolve2(__dirname, "../../content");
+var ALLOWED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".md",
+  ".yaml",
+  ".yml",
+  ".sh",
+  ".ts",
+  ".js",
+  ".json",
+  ".py",
+  ".txt"
+]);
+function resolveContentPath(relativePath) {
+  const base = GUIDE_ROOT ?? resolve2(__dirname, "../../..");
+  const resolved = resolve2(base, relativePath);
+  if (!resolved.startsWith(base + sep)) return null;
+  const ext = relativePath.slice(relativePath.lastIndexOf("."));
+  if (!ALLOWED_EXTENSIONS.has(ext)) return null;
+  return resolved;
+}
+function isDevMode() {
+  return GUIDE_ROOT !== null;
+}
+function getGuideRoot() {
+  return GUIDE_ROOT ?? resolve2(__dirname, "../../..");
+}
+var referenceCache = null;
+var releasesCache = null;
+var threatDbCache = null;
+function loadReference() {
+  if (referenceCache) return referenceCache;
+  const filePath = join(CONTENT_DIR, "reference.yaml");
+  const raw = parseYaml(readFileSync2(filePath, "utf8"));
+  const entries = [];
+  flattenReference(raw, "", entries);
+  referenceCache = {
+    version: raw.version ?? "unknown",
+    entries,
+    raw
+  };
+  return referenceCache;
+}
+function loadReleases() {
+  if (releasesCache) return releasesCache;
+  const filePath = join(CONTENT_DIR, "claude-code-releases.yaml");
+  const raw = parseYaml(readFileSync2(filePath, "utf8"));
+  releasesCache = {
+    latest: raw.latest ?? "unknown",
+    updated: raw.updated ?? "unknown",
+    releases: raw.releases ?? [],
+    raw
+  };
+  return releasesCache;
+}
+async function loadThreatDb() {
+  if (threatDbCache) return threatDbCache;
+  const THREAT_DB_PATH = "examples/commands/resources/threat-db.yaml";
+  let content;
+  if (GUIDE_ROOT) {
+    content = readFileSync2(join(GUIDE_ROOT, THREAT_DB_PATH), "utf8");
+  } else {
+    const fetched = await fetchFile(THREAT_DB_PATH);
+    if (!fetched) throw new Error("Failed to load threat-db.yaml");
+    content = fetched;
+  }
+  const raw = parseYaml(content);
+  threatDbCache = {
+    version: raw.version ?? "unknown",
+    updated: raw.updated ?? "unknown",
+    sources: raw.sources ?? [],
+    malicious_authors: raw.malicious_authors ?? [],
+    malicious_skills: raw.malicious_skills ?? [],
+    cve_database: raw.cve_database ?? [],
+    attack_techniques: raw.attack_techniques ?? [],
+    minimum_safe_versions: raw.minimum_safe_versions ?? {},
+    raw
+  };
+  return threatDbCache;
+}
+function loadLlmsTxt() {
+  const filePath = join(CONTENT_DIR, "llms.txt");
+  return readFileSync2(filePath, "utf8");
+}
+function getReferenceYamlRaw() {
+  const filePath = join(CONTENT_DIR, "reference.yaml");
+  return readFileSync2(filePath, "utf8");
+}
+function getReleasesYamlRaw() {
+  const filePath = join(CONTENT_DIR, "claude-code-releases.yaml");
+  return readFileSync2(filePath, "utf8");
+}
+function resolveDeepDive(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "number") {
+    return { type: "line", file: "guide/ultimate-guide.md", line: value };
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      return { type: "url", url: value };
+    }
+    const filePathMatch = value.match(/^(guide\/|examples\/|whitepapers\/|machine-readable\/)(.+?)(?::(\d+))?$/);
+    if (filePathMatch) {
+      return {
+        type: "file",
+        path: filePathMatch[1] + filePathMatch[2],
+        line: filePathMatch[3] ? parseInt(filePathMatch[3], 10) : void 0
+      };
+    }
+    return { type: "inline", text: value };
+  }
+  if (typeof value === "object") {
+    return { type: "structured", data: value };
+  }
+  return { type: "inline", text: String(value) };
+}
+function flattenReference(obj, prefix, entries) {
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}_${key}` : key;
+    if (key === "version" || key === "generated" || key === "description" || key === "note") {
+      continue;
+    }
+    if (value === null || value === void 0) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const obj2 = value;
+      const hasDeepDive = "deep_dive" in obj2;
+      const hasNestedObjects = Object.values(obj2).some(
+        (v) => typeof v === "object" && v !== null && !Array.isArray(v) && !("deep_dive" in v)
+      );
+      if (hasDeepDive || !hasNestedObjects) {
+        const searchableText = buildSearchableText(fullKey, value);
+        const target = hasDeepDive ? resolveDeepDive(obj2.deep_dive) : resolveDeepDive(value);
+        entries.push({
+          key: fullKey,
+          section: prefix.split("_")[0] ?? fullKey,
+          value,
+          searchableText,
+          target
+        });
+      } else {
+        flattenReference(obj2, fullKey, entries);
+      }
+    } else {
+      const searchableText = buildSearchableText(fullKey, value);
+      const target = resolveDeepDive(value);
+      entries.push({
+        key: fullKey,
+        section: prefix.split("_")[0] ?? fullKey,
+        value,
+        searchableText,
+        target
+      });
+    }
+  }
+}
+function buildSearchableText(key, value) {
+  const parts = [key.replace(/_/g, " ")];
+  if (typeof value === "string") {
+    parts.push(value);
+  } else if (typeof value === "number") {
+    parts.push(String(value));
+  } else if (Array.isArray(value)) {
+    for (const item of value) {
+      if (typeof item === "string") parts.push(item);
+      else if (typeof item === "object" && item !== null) {
+        parts.push(JSON.stringify(item));
+      }
+    }
+  } else if (typeof value === "object" && value !== null) {
+    parts.push(JSON.stringify(value));
+  }
+  return parts.join(" ").toLowerCase();
+}
+
+export {
+  __export,
+  fetchFile,
+  resolveContentPath,
+  isDevMode,
+  getGuideRoot,
+  loadReference,
+  loadReleases,
+  loadThreatDb,
+  loadLlmsTxt,
+  getReferenceYamlRaw,
+  getReleasesYamlRaw,
+  resolveDeepDive
+};
+//# sourceMappingURL=chunk-2OLPHMWN.js.map

package/dist/content-LZDXNAPI.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import {
+  getGuideRoot,
+  getReferenceYamlRaw,
+  getReleasesYamlRaw,
+  isDevMode,
+  loadLlmsTxt,
+  loadReference,
+  loadReleases,
+  loadThreatDb,
+  resolveContentPath,
+  resolveDeepDive
+} from "./chunk-2OLPHMWN.js";
+export {
+  getGuideRoot,
+  getReferenceYamlRaw,
+  getReleasesYamlRaw,
+  isDevMode,
+  loadLlmsTxt,
+  loadReference,
+  loadReleases,
+  loadThreatDb,
+  resolveContentPath,
+  resolveDeepDive
+};
+//# sourceMappingURL=content-LZDXNAPI.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }