onto-mcp 0.3.2 → 0.4.0

package/dist/core-runtime/readers/scan-tarball.test.js

@@ -1,283 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-// Mock child_process (for tar xzf) before importing the module under test
-vi.mock("node:child_process", () => ({
-    execSync: vi.fn(),
-}));
-// Mock scan-local before importing the module under test
-vi.mock("./scan-local.js", () => ({
-    scanLocal: vi.fn(() => ({
-        source: { type: "add-dir", path: "/tmp/mock" },
-        scanned_at: new Date().toISOString(),
-        files: [{ path: "index.ts", category: "source", language: "typescript", size_bytes: 100 }],
-        content_hashes: { "dir-hash": "abc123" },
-        dependency_graph: [],
-        api_patterns: [],
-        schema_patterns: [],
-        config_patterns: [],
-        doc_structure: [],
-    })),
-}));
-import { scanTarball } from "./scan-tarball.js";
-import { execSync } from "node:child_process";
-import { isScanError, isScanSkipped } from "./types.js";
-const mockedExecSync = vi.mocked(execSync);
-function makeSource(url) {
-    return { type: "github-tarball", url };
-}
-// Helper: create a mock Response
-function mockResponse(status, body = null, extraHeaders) {
-    const headers = new Headers(extraHeaders);
-    return {
-        ok: status >= 200 && status < 300,
-        status,
-        statusText: status === 200 ? "OK" : "Error",
-        arrayBuffer: async () => body ?? new ArrayBuffer(0),
-        headers,
-        redirected: false,
-        type: "basic",
-        url: "",
-        body: null,
-        bodyUsed: false,
-        clone: () => mockResponse(status, body, extraHeaders),
-        blob: async () => new Blob(),
-        formData: async () => new FormData(),
-        json: async () => ({}),
-        text: async () => "",
-    };
-}
-describe("scanTarball", () => {
-    const originalFetch = globalThis.fetch;
-    const originalEnv = process.env.GITHUB_TOKEN;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        delete process.env.GITHUB_TOKEN;
-        // Default: tar xzf succeeds (no-op)
-        mockedExecSync.mockReturnValue(Buffer.from(""));
-    });
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-        if (originalEnv !== undefined) {
-            process.env.GITHUB_TOKEN = originalEnv;
-        }
-        else {
-            delete process.env.GITHUB_TOKEN;
-        }
-    });
-    it("returns ScanResult on successful 200 response", async () => {
-        const source = makeSource("https://github.com/acme/my-repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(false);
-        const scan = result;
-        expect(scan.source).toBe(source);
-        expect(scan.files.length).toBeGreaterThanOrEqual(1);
-        // Verify fetch was called with correct URL
-        expect(globalThis.fetch).toHaveBeenCalledWith("https://api.github.com/repos/acme/my-repo/tarball/HEAD", expect.objectContaining({
-            headers: expect.objectContaining({
-                Accept: "application/vnd.github+json",
-            }),
-        }));
-        // Verify tar was called
-        expect(mockedExecSync).toHaveBeenCalledWith("tar xzf tarball.tar.gz --strip-components=1", expect.objectContaining({ timeout: 120_000 }));
-    });
-    it("sends Authorization header when GITHUB_TOKEN is set", async () => {
-        process.env.GITHUB_TOKEN = "ghp_test123";
-        const source = makeSource("https://github.com/acme/my-repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        await scanTarball(source);
-        expect(globalThis.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: "Bearer ghp_test123",
-            }),
-        }));
-    });
-    it("returns ScanError with error_type 'parse' for invalid GitHub URL", async () => {
-        const source = makeSource("https://not-github.com/broken");
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("parse");
-        expect(err.message).toContain("Invalid GitHub URL");
-        expect(err.source).toBe(source);
-    });
-    it("returns ScanError with error_type 'auth' on 401", async () => {
-        const source = makeSource("https://github.com/acme/private-repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(401));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("auth");
-        expect(err.message).toContain("Authentication failed");
-    });
-    it("returns ScanError with error_type 'auth' on 403", async () => {
-        const source = makeSource("https://github.com/acme/forbidden-repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(403));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("auth");
-    });
-    it("returns ScanError with error_type 'not_found' on 404", async () => {
-        const source = makeSource("https://github.com/acme/nonexistent");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(404));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("not_found");
-        expect(err.message).toContain("Repository not found");
-    });
-    it("returns ScanError with error_type 'network' on other HTTP errors", async () => {
-        const source = makeSource("https://github.com/acme/broken-repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(500));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("network");
-        expect(err.message).toContain("Failed to download");
-    });
-    it("returns ScanError with error_type 'network' on fetch rejection", async () => {
-        const source = makeSource("https://github.com/acme/broken-repo");
-        globalThis.fetch = vi.fn().mockRejectedValue(new Error("ECONNRESET: connection reset"));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("network");
-        expect(err.message).toContain("Failed to download");
-    });
-    it("returns ScanError with error_type 'timeout' on AbortError/timeout", async () => {
-        const source = makeSource("https://github.com/acme/slow-repo");
-        const abortError = new DOMException("The operation was aborted due to timeout", "TimeoutError");
-        globalThis.fetch = vi.fn().mockRejectedValue(abortError);
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("timeout");
-        expect(err.message).toContain("Timeout");
-    });
-    it("strips .git suffix from repo path in fetch URL", async () => {
-        const source = makeSource("https://github.com/acme/repo.git");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(false);
-        expect(globalThis.fetch).toHaveBeenCalledWith("https://api.github.com/repos/acme/repo/tarball/HEAD", expect.any(Object));
-    });
-    it("cleans up tmpdir on success", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        // No error thrown means cleanup succeeded
-        await scanTarball(source);
-        expect(true).toBe(true);
-    });
-    it("cleans up tmpdir on fetch failure", async () => {
-        const source = makeSource("https://github.com/acme/fail-repo");
-        globalThis.fetch = vi.fn().mockRejectedValue(new Error("ECONNRESET"));
-        // No error thrown means cleanup succeeded
-        await scanTarball(source);
-        expect(true).toBe(true);
-    });
-});
-describe("isScanError", () => {
-    it("returns true for ScanError objects", () => {
-        const err = {
-            source: makeSource("https://github.com/a/b"),
-            error_type: "network",
-            message: "fail",
-        };
-        expect(isScanError(err)).toBe(true);
-    });
-    it("returns false for ScanResult objects", () => {
-        const result = {
-            source: makeSource("https://github.com/a/b"),
-            scanned_at: new Date().toISOString(),
-            files: [],
-            content_hashes: {},
-            dependency_graph: [],
-            api_patterns: [],
-            schema_patterns: [],
-            config_patterns: [],
-            doc_structure: [],
-        };
-        expect(isScanError(result)).toBe(false);
-    });
-    it("returns false for ScanSkipped objects", () => {
-        const skipped = {
-            skipped: true,
-            source: makeSource("https://github.com/a/b"),
-            cached_hash: "abc",
-        };
-        expect(isScanError(skipped)).toBe(false);
-    });
-});
-describe("ETag caching", () => {
-    const originalFetch = globalThis.fetch;
-    const originalEnv = process.env.GITHUB_TOKEN;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        delete process.env.GITHUB_TOKEN;
-        mockedExecSync.mockReturnValue(Buffer.from(""));
-    });
-    afterEach(() => {
-        globalThis.fetch = originalFetch;
-        if (originalEnv !== undefined) {
-            process.env.GITHUB_TOKEN = originalEnv;
-        }
-        else {
-            delete process.env.GITHUB_TOKEN;
-        }
-    });
-    it("sends If-None-Match header when etag is provided", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        await scanTarball(source, '"etag-abc"');
-        expect(globalThis.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            headers: expect.objectContaining({
-                "If-None-Match": '"etag-abc"',
-            }),
-        }));
-    });
-    it("returns ScanSkipped on 304 with previousHash", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(304));
-        const result = await scanTarball(source, '"etag-abc"', "prev-hash-123");
-        expect(isScanError(result)).toBe(false);
-        expect(isScanSkipped(result)).toBe(true);
-        const skipped = result;
-        expect(skipped.skipped).toBe(true);
-        expect(skipped.source).toBe(source);
-        expect(skipped.cached_hash).toBe("prev-hash-123");
-    });
-    it("returns network error on 304 without previousHash", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(304));
-        const result = await scanTarball(source, '"etag-abc"');
-        // 304 without previousHash falls through to !response.ok error handling
-        expect(isScanError(result)).toBe(true);
-        const err = result;
-        expect(err.error_type).toBe("network");
-    });
-    it("extracts ETag from 200 response headers", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8), { ETag: '"new-etag-xyz"' }));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(false);
-        expect(isScanSkipped(result)).toBe(false);
-        const scan = result;
-        expect(scan.response_etag).toBe('"new-etag-xyz"');
-    });
-    it("sets response_etag to undefined when no ETag header", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(200, new ArrayBuffer(8)));
-        const result = await scanTarball(source);
-        expect(isScanError(result)).toBe(false);
-        const scan = result;
-        expect(scan.response_etag).toBeUndefined();
-    });
-    it("does not download tarball on 304 (no tar, no scanLocal)", async () => {
-        const source = makeSource("https://github.com/acme/repo");
-        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse(304));
-        await scanTarball(source, '"etag"', "hash");
-        // tar should NOT be called (gh auth token may be called for token resolution)
-        const tarCalls = mockedExecSync.mock.calls.filter(([cmd]) => String(cmd).includes("tar"));
-        expect(tarCalls).toHaveLength(0);
-    });
-});

package/dist/core-runtime/readers/scan-vault.js

@@ -1,34 +0,0 @@
-import { statSync } from "node:fs";
-import { normalizePath } from "./file-utils.js";
-import { scanDirectory } from "./scan-local.js";
-import { sourceKey, emptyScanResult } from "./types.js";
-/**
- * Scan an Obsidian vault directory.
- * Delegates to scanDirectory (shared with scanLocal) and re-keys the result
- * so that content_hashes uses "obsidian-vault:{path}" instead of "add-dir:{path}".
- */
-export function scanVault(source) {
-    const fullPath = normalizePath(source.path);
-    try {
-        const stat = statSync(fullPath);
-        if (!stat.isDirectory()) {
-            return emptyScanResult(source);
-        }
-    }
-    catch {
-        return emptyScanResult(source);
-    }
-    // .obsidian/ is already in ALWAYS_EXCLUDE_DIRS in file-utils.ts
-    const result = scanDirectory(source, fullPath);
-    // Ensure content_hashes key uses obsidian-vault:{path} and source is the original
-    const vaultKey = sourceKey(source);
-    const hashes = {};
-    for (const value of Object.values(result.content_hashes)) {
-        hashes[vaultKey] = value;
-    }
-    return {
-        ...result,
-        source,
-        content_hashes: hashes,
-    };
-}

package/dist/core-runtime/readers/scan-vault.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { scanVault } from "./scan-vault.js";
-const TMP = join(import.meta.dirname ?? ".", ".tmp-scanvault-test");
-function makeSource(path) {
-    return { type: "obsidian-vault", path };
-}
-beforeEach(() => mkdirSync(TMP, { recursive: true }));
-afterEach(() => rmSync(TMP, { recursive: true, force: true }));
-describe("scanVault", () => {
-    it("scans a vault directory and returns ScanResult", () => {
-        writeFileSync(join(TMP, "note.md"), "# Hello\n\nSome content here.");
-        writeFileSync(join(TMP, "idea.md"), "# Idea\n\n## Sub-heading\n\nDetails.");
-        const result = scanVault(makeSource(TMP));
-        expect(result.files.length).toBeGreaterThanOrEqual(2);
-        expect(result.scanned_at).toBeTruthy();
-        expect(result.source.type).toBe("obsidian-vault");
-        expect(Object.keys(result.content_hashes).length).toBeGreaterThan(0);
-    });
-    it("excludes .obsidian/ directory", () => {
-        mkdirSync(join(TMP, ".obsidian"), { recursive: true });
-        writeFileSync(join(TMP, ".obsidian", "app.json"), '{"key": "value"}');
-        writeFileSync(join(TMP, ".obsidian", "workspace.json"), "{}");
-        writeFileSync(join(TMP, "note.md"), "# Note\n\nContent.");
-        const result = scanVault(makeSource(TMP));
-        const paths = result.files.map((f) => f.path);
-        expect(paths).toContain("note.md");
-        expect(paths.every((p) => !p.includes(".obsidian"))).toBe(true);
-    });
-    // Depends on patterns/ module (deferred — code parser infrastructure not yet absorbed)
-    it.skip("extracts doc_structure from markdown files", () => {
-        writeFileSync(join(TMP, "structured.md"), "# Title\n\n## Section A\n\n## Section B\n\nParagraph text.");
-        const result = scanVault(makeSource(TMP));
-        expect(result.doc_structure.length).toBeGreaterThan(0);
-        const doc = result.doc_structure.find((d) => d.file === "structured.md");
-        expect(doc).toBeDefined();
-        expect(doc.format).toBe("markdown");
-        expect(doc.headings).toBeDefined();
-        expect(doc.headings.length).toBeGreaterThanOrEqual(2);
-    });
-    it("returns empty ScanResult for non-existent path", () => {
-        const result = scanVault(makeSource(join(TMP, "does-not-exist")));
-        expect(result.files).toEqual([]);
-        expect(result.dependency_graph).toEqual([]);
-        expect(result.api_patterns).toEqual([]);
-        expect(result.schema_patterns).toEqual([]);
-        expect(result.config_patterns).toEqual([]);
-        expect(result.doc_structure).toEqual([]);
-    });
-    it("returns empty ScanResult when path points to a file (not a directory)", () => {
-        const filePath = join(TMP, "single-file.md");
-        writeFileSync(filePath, "# Just a file");
-        const result = scanVault(makeSource(filePath));
-        expect(result.files).toEqual([]);
-        expect(result.dependency_graph).toEqual([]);
-    });
-    it("also excludes .git and node_modules like scanLocal", () => {
-        mkdirSync(join(TMP, ".git"), { recursive: true });
-        writeFileSync(join(TMP, ".git", "config"), "git config");
-        mkdirSync(join(TMP, "node_modules", "pkg"), { recursive: true });
-        writeFileSync(join(TMP, "node_modules", "pkg", "index.js"), "code");
-        writeFileSync(join(TMP, "note.md"), "# Note");
-        const result = scanVault(makeSource(TMP));
-        const paths = result.files.map((f) => f.path);
-        expect(paths).toEqual(["note.md"]);
-    });
-    it("scans nested directories inside vault", () => {
-        mkdirSync(join(TMP, "projects"), { recursive: true });
-        mkdirSync(join(TMP, "daily"), { recursive: true });
-        writeFileSync(join(TMP, "projects", "project-a.md"), "# Project A");
-        writeFileSync(join(TMP, "daily", "2024-01-01.md"), "# Daily Note");
-        writeFileSync(join(TMP, "index.md"), "# Index");
-        const result = scanVault(makeSource(TMP));
-        expect(result.files.length).toBe(3);
-        const paths = result.files.map((f) => f.path).sort();
-        expect(paths).toContain("index.md");
-        expect(paths).toContain("projects/project-a.md");
-        expect(paths).toContain("daily/2024-01-01.md");
-    });
-});

package/dist/core-runtime/readers/types.js

@@ -1,42 +0,0 @@
-// ─── Source Entry (re-exported from kernel) ───
-export { sourceKey } from "../scope-runtime/types.js";
-// ─── Normalize to GroundingStartedPayload format ───
-export function toGroundingSource(entry) {
-    switch (entry.type) {
-        case "add-dir":
-            return { type: "add-dir", path_or_url: entry.path };
-        case "github-tarball":
-            return { type: "github-tarball", path_or_url: entry.url };
-        case "figma-mcp":
-            return { type: "figma-mcp", path_or_url: entry.file_key };
-        case "obsidian-vault":
-            return { type: "obsidian-vault", path_or_url: entry.path };
-        case "mcp":
-            return { type: "mcp", path_or_url: entry.provider };
-        default: {
-            const _exhaustive = entry;
-            throw new Error(`Unknown source type: ${entry.type}`);
-        }
-    }
-}
-// ─── Empty Scan Result Factory ───
-export function emptyScanResult(source) {
-    return {
-        source,
-        scanned_at: new Date().toISOString(),
-        files: [],
-        content_hashes: {},
-        dependency_graph: [],
-        api_patterns: [],
-        schema_patterns: [],
-        config_patterns: [],
-        doc_structure: [],
-    };
-}
-export function isScanSkipped(result) {
-    return "skipped" in result && result.skipped === true;
-}
-/** Type guard for ScanError */
-export function isScanError(result) {
-    return "error_type" in result;
-}

package/dist/core-runtime/readers/types.test.js

@@ -1,94 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { sourceKey, toGroundingSource, isScanError, isScanSkipped } from "./types.js";
-describe("sourceKey", () => {
-    it("add-dir", () => {
-        expect(sourceKey({ type: "add-dir", path: "./src" })).toBe("add-dir:./src");
-    });
-    it("github-tarball", () => {
-        expect(sourceKey({ type: "github-tarball", url: "https://github.com/org/repo" }))
-            .toBe("github-tarball:https://github.com/org/repo");
-    });
-    it("figma-mcp", () => {
-        expect(sourceKey({ type: "figma-mcp", file_key: "abc" })).toBe("figma-mcp:abc");
-    });
-    it("obsidian-vault", () => {
-        expect(sourceKey({ type: "obsidian-vault", path: "/vaults/docs" }))
-            .toBe("obsidian-vault:/vaults/docs");
-    });
-    it("mcp", () => {
-        expect(sourceKey({ type: "mcp", provider: "my-provider" }))
-            .toBe("mcp:my-provider");
-    });
-});
-describe("toGroundingSource", () => {
-    it("normalizes add-dir", () => {
-        expect(toGroundingSource({ type: "add-dir", path: "./src" }))
-            .toEqual({ type: "add-dir", path_or_url: "./src" });
-    });
-    it("normalizes github-tarball", () => {
-        expect(toGroundingSource({ type: "github-tarball", url: "https://github.com/org/repo" }))
-            .toEqual({ type: "github-tarball", path_or_url: "https://github.com/org/repo" });
-    });
-    it("normalizes figma-mcp", () => {
-        expect(toGroundingSource({ type: "figma-mcp", file_key: "abc" }))
-            .toEqual({ type: "figma-mcp", path_or_url: "abc" });
-    });
-    it("normalizes obsidian-vault", () => {
-        expect(toGroundingSource({ type: "obsidian-vault", path: "/vaults" }))
-            .toEqual({ type: "obsidian-vault", path_or_url: "/vaults" });
-    });
-    it("normalizes mcp", () => {
-        expect(toGroundingSource({ type: "mcp", provider: "my-provider" }))
-            .toEqual({ type: "mcp", path_or_url: "my-provider" });
-    });
-});
-describe("isScanSkipped", () => {
-    const source = { type: "github-tarball", url: "https://github.com/a/b" };
-    it("returns true for ScanSkipped", () => {
-        const skipped = { skipped: true, source, cached_hash: "abc123" };
-        expect(isScanSkipped(skipped)).toBe(true);
-    });
-    it("returns false for ScanResult", () => {
-        const result = {
-            source,
-            scanned_at: new Date().toISOString(),
-            files: [],
-            content_hashes: {},
-            dependency_graph: [],
-            api_patterns: [],
-            schema_patterns: [],
-            config_patterns: [],
-            doc_structure: [],
-        };
-        expect(isScanSkipped(result)).toBe(false);
-    });
-    it("returns false for ScanError", () => {
-        const err = { source, error_type: "network", message: "fail" };
-        expect(isScanSkipped(err)).toBe(false);
-    });
-});
-describe("isScanError", () => {
-    const source = { type: "github-tarball", url: "https://github.com/a/b" };
-    it("returns true for ScanError", () => {
-        const err = { source, error_type: "network", message: "fail" };
-        expect(isScanError(err)).toBe(true);
-    });
-    it("returns false for ScanResult", () => {
-        const result = {
-            source,
-            scanned_at: new Date().toISOString(),
-            files: [],
-            content_hashes: {},
-            dependency_graph: [],
-            api_patterns: [],
-            schema_patterns: [],
-            config_patterns: [],
-            doc_structure: [],
-        };
-        expect(isScanError(result)).toBe(false);
-    });
-    it("returns false for ScanSkipped", () => {
-        const skipped = { skipped: true, source, cached_hash: "abc" };
-        expect(isScanError(skipped)).toBe(false);
-    });
-});