contextqmd 0.1.0

package/dist/lib/local-cache.js

@@ -0,0 +1,183 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+export function normalizeDocPath(docPath) {
+    const trimmed = docPath.replace(/\\/g, "/").replace(/^\/+/, "");
+    return trimmed.endsWith(".md") ? trimmed : `${trimmed}.md`;
+}
+function normalizePageUid(pageUid) {
+    const trimmed = pageUid.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!trimmed || trimmed.split("/").includes("..")) {
+        throw new Error(`Unsafe page_uid: ${pageUid}`);
+    }
+    return trimmed;
+}
+export class LocalCache {
+    cacheDir;
+    constructor(cacheDir) {
+        this.cacheDir = cacheDir;
+        mkdirSync(join(this.cacheDir, "docs"), { recursive: true });
+        mkdirSync(join(this.cacheDir, "state"), { recursive: true });
+        mkdirSync(join(this.cacheDir, "tmp"), { recursive: true });
+    }
+    docsDir(namespace, name, version) {
+        return join(this.cacheDir, "docs", namespace, name, version);
+    }
+    pagesDir(namespace, name, version) {
+        return join(this.docsDir(namespace, name, version), "pages");
+    }
+    saveManifest(namespace, name, version, manifest) {
+        const dir = this.docsDir(namespace, name, version);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "manifest.json"), JSON.stringify(manifest, null, 2));
+    }
+    savePageIndex(namespace, name, version, pageIndex) {
+        const dir = this.docsDir(namespace, name, version);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "page-index.json"), JSON.stringify(pageIndex, null, 2));
+    }
+    loadPageIndex(namespace, name, version) {
+        const path = join(this.docsDir(namespace, name, version), "page-index.json");
+        if (!existsSync(path))
+            return [];
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    findPageByUid(namespace, name, version, pageUid) {
+        return this.loadPageIndex(namespace, name, version).find(page => page.page_uid === pageUid) ?? null;
+    }
+    findPageByPath(namespace, name, version, docPath) {
+        const normalized = normalizeDocPath(docPath);
+        return this.loadPageIndex(namespace, name, version)
+            .find(page => normalizeDocPath(page.path) === normalized) ?? null;
+    }
+    savePage(namespace, name, version, pageUid, content) {
+        const path = this.pagePath(namespace, name, version, pageUid);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, content);
+    }
+    readPage(namespace, name, version, pageUid) {
+        const path = this.pagePath(namespace, name, version, pageUid);
+        if (!existsSync(path))
+            return null;
+        return readFileSync(path, "utf-8");
+    }
+    hasManifest(namespace, name, version) {
+        return existsSync(join(this.docsDir(namespace, name, version), "manifest.json"));
+    }
+    countPages(namespace, name, version) {
+        const pageIndex = this.loadPageIndex(namespace, name, version);
+        if (pageIndex.length > 0)
+            return pageIndex.length;
+        const dir = this.pagesDir(namespace, name, version);
+        if (!existsSync(dir))
+            return 0;
+        return this.collectMarkdownFiles(dir).length;
+    }
+    listPageUids(namespace, name, version) {
+        const pageIndex = this.loadPageIndex(namespace, name, version);
+        if (pageIndex.length > 0)
+            return pageIndex.map(page => page.page_uid);
+        const dir = this.pagesDir(namespace, name, version);
+        if (!existsSync(dir))
+            return [];
+        return this.collectMarkdownFiles(dir).map(file => file.replace(/\.md$/, ""));
+    }
+    removeVersion(namespace, name, version) {
+        const dir = this.docsDir(namespace, name, version);
+        if (existsSync(dir)) {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    createTempInstallDir(namespace, name, version) {
+        const prefix = `${namespace}-${name}-${version}-`.replace(/[^a-zA-Z0-9._-]/g, "-");
+        return mkdtempSync(join(this.cacheDir, "tmp", prefix));
+    }
+    createTempArchivePath(namespace, name, version, filename = "bundle.tar.gz") {
+        const dir = this.createTempInstallDir(namespace, name, version);
+        return join(dir, filename);
+    }
+    commitStagedVersion(namespace, name, version, stagedDocsDir) {
+        const finalDir = this.docsDir(namespace, name, version);
+        const parentDir = join(this.cacheDir, "docs", namespace, name);
+        mkdirSync(parentDir, { recursive: true });
+        if (existsSync(finalDir)) {
+            rmSync(finalDir, { recursive: true, force: true });
+        }
+        renameSync(stagedDocsDir, finalDir);
+    }
+    backupVersion(namespace, name, version) {
+        const finalDir = this.docsDir(namespace, name, version);
+        if (!existsSync(finalDir))
+            return null;
+        const backupRoot = this.createTempInstallDir(namespace, name, version);
+        const backupDir = join(backupRoot, "docs");
+        renameSync(finalDir, backupDir);
+        return backupDir;
+    }
+    restoreVersionFromBackup(namespace, name, version, backupDir) {
+        const finalDir = this.docsDir(namespace, name, version);
+        const parentDir = join(this.cacheDir, "docs", namespace, name);
+        if (existsSync(finalDir)) {
+            rmSync(finalDir, { recursive: true, force: true });
+        }
+        if (existsSync(backupDir)) {
+            mkdirSync(parentDir, { recursive: true });
+            renameSync(backupDir, finalDir);
+        }
+        this.cleanupTempPath(dirname(backupDir));
+    }
+    discardBackup(backupDir) {
+        this.cleanupTempPath(dirname(backupDir));
+    }
+    cleanupTempPath(path) {
+        if (existsSync(path)) {
+            rmSync(path, { recursive: true, force: true });
+        }
+    }
+    statePath() {
+        return join(this.cacheDir, "state", "installed.json");
+    }
+    loadState() {
+        const path = this.statePath();
+        if (!existsSync(path))
+            return { libraries: [] };
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    saveState(state) {
+        writeFileSync(this.statePath(), JSON.stringify(state, null, 2));
+    }
+    findInstalled(namespace, name, version) {
+        return this.loadState().libraries.find(lib => lib.namespace === namespace && lib.name === name && (!version || lib.version === version));
+    }
+    addInstalled(lib) {
+        const state = this.loadState();
+        state.libraries = state.libraries.filter(existing => !(existing.namespace === lib.namespace && existing.name === lib.name && existing.version === lib.version));
+        state.libraries.push(lib);
+        this.saveState(state);
+    }
+    removeInstalled(namespace, name, version) {
+        const state = this.loadState();
+        state.libraries = state.libraries.filter(lib => !(lib.namespace === namespace && lib.name === name && lib.version === version));
+        this.saveState(state);
+    }
+    listInstalled() {
+        return this.loadState().libraries;
+    }
+    pagePath(namespace, name, version, pageUid) {
+        return join(this.pagesDir(namespace, name, version), `${normalizePageUid(pageUid)}.md`);
+    }
+    collectMarkdownFiles(path, relativeDir = "") {
+        const files = [];
+        for (const entry of readdirSync(path, { withFileTypes: true })) {
+            const nextRelative = relativeDir ? join(relativeDir, entry.name) : entry.name;
+            const nextPath = join(path, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...this.collectMarkdownFiles(nextPath, nextRelative));
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith(".md")) {
+                files.push(nextRelative.replace(/\\/g, "/"));
+            }
+        }
+        return files;
+    }
+}

package/dist/lib/registry-client.js

@@ -0,0 +1,100 @@
+export class RegistryClient {
+    registryUrl;
+    baseUrl;
+    token;
+    constructor(registryUrl, token) {
+        this.registryUrl = registryUrl.replace(/\/$/, "");
+        this.baseUrl = `${this.registryUrl}/api/v1`;
+        this.token = token;
+    }
+    async health() {
+        return this.get("health");
+    }
+    async capabilities() {
+        return this.get("capabilities");
+    }
+    async searchLibraries(query, cursor) {
+        const params = new URLSearchParams({ query });
+        if (cursor)
+            params.set("cursor", cursor);
+        return this.get(`libraries?${params}`);
+    }
+    async getLibrary(namespace, name) {
+        return this.get(`libraries/${namespace}/${name}`);
+    }
+    async getVersions(namespace, name, cursor) {
+        const params = cursor ? `?cursor=${cursor}` : "";
+        return this.get(`libraries/${namespace}/${name}/versions${params}`);
+    }
+    async getManifest(namespace, name, version) {
+        return this.get(`libraries/${namespace}/${name}/versions/${version}/manifest`);
+    }
+    async getPageIndex(namespace, name, version, cursor) {
+        const params = cursor ? `?cursor=${cursor}` : "";
+        return this.get(`libraries/${namespace}/${name}/versions/${version}/page-index${params}`);
+    }
+    async getAllPageIndex(namespace, name, version) {
+        const maxFetches = 100;
+        const allPages = [];
+        let cursor;
+        let iterations = 0;
+        do {
+            if (++iterations > maxFetches) {
+                break;
+            }
+            const response = await this.getPageIndex(namespace, name, version, cursor);
+            allPages.push(...response.data);
+            cursor = response.meta.cursor ?? undefined;
+        } while (cursor);
+        return allPages;
+    }
+    async getPageContent(namespace, name, version, pageUid) {
+        return this.get(`libraries/${namespace}/${name}/versions/${version}/pages/${pageUid}`);
+    }
+    async resolve(request) {
+        return this.post("resolve", request);
+    }
+    async downloadBundle(bundleUrl) {
+        const res = await fetch(this.resolveUrl(bundleUrl), { headers: this.authHeaders() });
+        if (!res.ok) {
+            throw new Error(`Registry error ${res.status}: ${await res.text()}`);
+        }
+        return Buffer.from(await res.arrayBuffer());
+    }
+    async get(path) {
+        const res = await fetch(this.resolveUrl(path), { headers: this.headers() });
+        if (!res.ok) {
+            throw new Error(`Registry error ${res.status}: ${await res.text()}`);
+        }
+        return res.json();
+    }
+    async post(path, body) {
+        const res = await fetch(this.resolveUrl(path), {
+            method: "POST",
+            headers: { ...this.headers(), "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new Error(`Registry error ${res.status}: ${await res.text()}`);
+        }
+        return res.json();
+    }
+    resolveUrl(pathOrUrl) {
+        if (/^https?:\/\//.test(pathOrUrl)) {
+            return pathOrUrl;
+        }
+        if (pathOrUrl.startsWith("/")) {
+            return new URL(pathOrUrl, `${this.registryUrl}/`).toString();
+        }
+        return `${this.baseUrl}/${pathOrUrl.replace(/^\/+/, "")}`;
+    }
+    headers() {
+        const headers = { Accept: "application/json" };
+        if (this.token)
+            headers.Authorization = `Token ${this.token}`;
+        return headers;
+    }
+    authHeaders() {
+        return this.token ? { Authorization: `Token ${this.token}` } : {};
+    }
+}