@kaelio/ktx 0.13.0 → 0.14.0

package/dist/context/connections/read-only-sql.js

@@ -91,6 +91,143 @@ export function assertReadOnlySql(sql) {
     assertSingleSqlStatement(trimmed);
     return trimmed;
 }
+function isSqlIdentifierPart(char) {
+    return char !== undefined && /[A-Za-z0-9_$]/.test(char);
+}
+function keywordAt(sql, index, keyword) {
+    if (sql.slice(index, index + keyword.length).toLowerCase() !== keyword.toLowerCase()) {
+        return false;
+    }
+    return !isSqlIdentifierPart(sql[index - 1]) && !isSqlIdentifierPart(sql[index + keyword.length]);
+}
+function skipWhitespaceAndComments(sql, index) {
+    let current = index;
+    while (current < sql.length) {
+        while (/\s/.test(sql[current] ?? '')) {
+            current += 1;
+        }
+        if (sql.startsWith('--', current) || sql.startsWith('/*', current)) {
+            current = skipQuotedOrComment(sql, current);
+            continue;
+        }
+        return current;
+    }
+    return current;
+}
+function skipBracketIdentifier(sql, index) {
+    let current = index + 1;
+    while (current < sql.length) {
+        if (sql[current] === ']') {
+            if (sql[current + 1] === ']') {
+                current += 2;
+                continue;
+            }
+            return current + 1;
+        }
+        current += 1;
+    }
+    return -1;
+}
+function skipBacktickIdentifier(sql, index) {
+    let current = index + 1;
+    while (current < sql.length) {
+        if (sql[current] === '`') {
+            if (sql[current + 1] === '`') {
+                current += 2;
+                continue;
+            }
+            return current + 1;
+        }
+        current += 1;
+    }
+    return -1;
+}
+function skipIdentifier(sql, index) {
+    if (sql[index] === '"') {
+        const skipped = skipQuotedOrComment(sql, index);
+        return skipped > index ? skipped : -1;
+    }
+    if (sql[index] === '[') {
+        return skipBracketIdentifier(sql, index);
+    }
+    if (sql[index] === '`') {
+        return skipBacktickIdentifier(sql, index);
+    }
+    let current = index;
+    while (isSqlIdentifierPart(sql[current])) {
+        current += 1;
+    }
+    return current > index ? current : -1;
+}
+function skipBalancedParentheses(sql, index) {
+    if (sql[index] !== '(') {
+        return -1;
+    }
+    let current = index;
+    let depth = 0;
+    while (current < sql.length) {
+        const skipped = skipQuotedOrComment(sql, current);
+        if (skipped > current) {
+            current = skipped;
+            continue;
+        }
+        if (sql[current] === '(') {
+            depth += 1;
+        }
+        else if (sql[current] === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return current + 1;
+            }
+        }
+        current += 1;
+    }
+    return -1;
+}
+/** @internal */
+export function hoistLeadingCte(sql) {
+    const trimmed = sql.trim();
+    if (!keywordAt(trimmed, 0, 'with')) {
+        return { withPrefix: '', body: sql };
+    }
+    let current = skipWhitespaceAndComments(trimmed, 4);
+    if (keywordAt(trimmed, current, 'recursive')) {
+        current = skipWhitespaceAndComments(trimmed, current + 'recursive'.length);
+    }
+    while (current < trimmed.length) {
+        current = skipIdentifier(trimmed, current);
+        if (current < 0) {
+            return { withPrefix: '', body: trimmed };
+        }
+        current = skipWhitespaceAndComments(trimmed, current);
+        if (trimmed[current] === '(') {
+            current = skipBalancedParentheses(trimmed, current);
+            if (current < 0) {
+                return { withPrefix: '', body: trimmed };
+            }
+            current = skipWhitespaceAndComments(trimmed, current);
+        }
+        if (!keywordAt(trimmed, current, 'as')) {
+            return { withPrefix: '', body: trimmed };
+        }
+        current = skipWhitespaceAndComments(trimmed, current + 2);
+        current = skipBalancedParentheses(trimmed, current);
+        if (current < 0) {
+            return { withPrefix: '', body: trimmed };
+        }
+        current = skipWhitespaceAndComments(trimmed, current);
+        if (trimmed[current] === ',') {
+            current = skipWhitespaceAndComments(trimmed, current + 1);
+            continue;
+        }
+        const body = trimmed.slice(current).trimStart();
+        if (!body) {
+            return { withPrefix: '', body: trimmed };
+        }
+        return { withPrefix: `${trimmed.slice(0, current).trimEnd()} `, body };
+    }
+    return { withPrefix: '', body: trimmed };
+}
 // `assertReadOnlySql` deliberately keeps trailing semicolons, comments, and
 // whitespace (e.g. `select 1; -- done`) — harmless for direct single-statement
 // execution. A row-limit subquery wrapper needs a bare expression instead: a
@@ -130,5 +267,6 @@ export function limitSqlForExecution(sql, maxRows) {
     if (!Number.isInteger(maxRows) || maxRows <= 0) {
         throw new KtxQueryError('maxRows must be a positive integer.');
     }
-    return `select * from (${trimmed}) as ktx_query_result limit ${maxRows}`;
+    const { withPrefix, body } = hoistLeadingCte(trimmed);
+    return `${withPrefix}select * from (${body}) as ktx_query_result limit ${maxRows}`;
 }

package/dist/context/ingest/adapters/gdrive/chunk.d.ts

@@ -0,0 +1,3 @@
+import type { ChunkResult, DiffSet, ScopeDescriptor } from '../../types.js';
+export declare function chunkGdriveStagedDir(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
+export declare function describeGdriveScope(stagedDir: string): Promise<ScopeDescriptor>;

package/dist/context/ingest/adapters/gdrive/chunk.js

@@ -0,0 +1,74 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { gdriveManifestSchema, gdriveMetadataSchema } from './types.js';
+const GDRIVE_RECONCILE_GUIDANCE = 'Synthesize durable wiki knowledge from this Google Doc. Preserve product definitions, process documentation, and operating rules as wiki pages. Do not create semantic-layer sources from gdrive content in v1.';
+function normalizeRawPath(path) {
+    return path.replace(/\\/g, '/');
+}
+async function walk(root) {
+    const entries = await readdir(root, { withFileTypes: true, recursive: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => normalizeRawPath(relative(root, join(entry.parentPath, entry.name))))
+        .sort();
+}
+function safeUnitKey(path) {
+    return `gdrive-${path.replace(/^docs\//, '').replace(/\/page\.md$/, '').replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '')}`;
+}
+async function readManifest(stagedDir) {
+    try {
+        return gdriveManifestSchema.parse(JSON.parse(await readFile(join(stagedDir, 'manifest.json'), 'utf-8')));
+    }
+    catch (error) {
+        throw new Error(`Invalid gdrive manifest: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export async function chunkGdriveStagedDir(stagedDir, diffSet) {
+    const files = await walk(stagedDir);
+    const manifest = await readManifest(stagedDir);
+    const touched = diffSet
+        ? new Set([...diffSet.added, ...diffSet.modified].map((path) => normalizeRawPath(path)))
+        : null;
+    const workUnits = [];
+    for (const pagePath of files.filter((path) => path.endsWith('/page.md'))) {
+        const metadataPath = pagePath.replace(/\/page\.md$/, '/metadata.json');
+        const primary = [metadataPath, pagePath].filter((path) => files.includes(path));
+        if (touched && !primary.some((path) => touched.has(path))) {
+            continue;
+        }
+        const metadata = gdriveMetadataSchema.parse(JSON.parse(await readFile(join(stagedDir, metadataPath), 'utf-8')));
+        const rawFiles = touched ? primary.filter((path) => touched.has(path)).sort() : primary.sort();
+        const dependencyPaths = ['manifest.json'].filter((path) => !rawFiles.includes(path));
+        const excluded = new Set([...rawFiles, ...dependencyPaths]);
+        const peerFileIndex = files.filter((path) => !excluded.has(path)).sort();
+        workUnits.push({
+            unitKey: safeUnitKey(pagePath),
+            displayLabel: metadata.path,
+            rawFiles,
+            dependencyPaths,
+            peerFileIndex,
+            notes: GDRIVE_RECONCILE_GUIDANCE,
+        });
+    }
+    return {
+        workUnits,
+        eviction: diffSet && diffSet.deleted.length > 0
+            ? { deletedRawPaths: diffSet.deleted.map((path) => normalizeRawPath(path)).sort() }
+            : undefined,
+        reconcileNotes: ['Google Drive docs are knowledge-only in v1; keep output in wiki pages unless later follow-up work expands scope.'],
+        contextReport: { capped: false, warnings: manifest.warnings },
+    };
+}
+export async function describeGdriveScope(stagedDir) {
+    const manifest = await readManifest(stagedDir);
+    const scopeKey = JSON.stringify({
+        folderId: manifest.folderId,
+        recursive: manifest.recursive,
+    });
+    const fingerprint = createHash('sha256').update(scopeKey).digest('hex');
+    return {
+        fingerprint,
+        isPathInScope: (rawPath) => rawPath === 'manifest.json' || rawPath.startsWith('docs/'),
+    };
+}

package/dist/context/ingest/adapters/gdrive/detect.d.ts

@@ -0,0 +1 @@
+export declare function detectGdriveStagedDir(stagedDir: string): Promise<boolean>;

package/dist/context/ingest/adapters/gdrive/detect.js

@@ -0,0 +1,20 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function detectGdriveStagedDir(stagedDir) {
+    try {
+        const manifest = JSON.parse(await readFile(join(stagedDir, 'manifest.json'), 'utf-8'));
+        if (manifest.source === 'gdrive') {
+            return true;
+        }
+    }
+    catch {
+        // Fall through to structural detection.
+    }
+    try {
+        const entries = await readdir(stagedDir, { withFileTypes: true, recursive: true });
+        return entries.some((entry) => entry.isFile() && entry.name === 'page.md');
+    }
+    catch {
+        return false;
+    }
+}

package/dist/context/ingest/adapters/gdrive/fetch.d.ts

@@ -0,0 +1,6 @@
+import type { GdriveManifest, GdrivePullConfig } from './types.js';
+export declare function fetchGdriveSnapshot(params: {
+    key: unknown;
+    config: GdrivePullConfig;
+    stagedDir: string;
+}): Promise<GdriveManifest>;

package/dist/context/ingest/adapters/gdrive/fetch.js

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { createGoogleDocsClients, driveFolderChildrenQuery } from './gdrive-client.js';
+import { normalizeGoogleDocToMarkdown } from './normalize.js';
+import { GDRIVE_DOC_MIME_TYPE, GDRIVE_FOLDER_MIME_TYPE, GDRIVE_SOURCE_KEY } from './types.js';
+async function writeJson(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
+}
+async function writeText(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, value.endsWith('\n') ? value : `${value}\n`, 'utf-8');
+}
+function slugifySegment(value) {
+    const normalized = value
+        .normalize('NFKD')
+        .replace(/[^\x00-\x7F]/g, '')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+    return normalized || 'untitled';
+}
+function compactSegment(value, maxLength = 24) {
+    const slug = slugifySegment(value);
+    return slug.length > maxLength ? slug.slice(0, maxLength).replace(/-+$/g, '') || 'untitled' : slug;
+}
+function shortHash(value, length = 10) {
+    return createHash('sha1').update(value).digest('hex').slice(0, length);
+}
+function gdriveDocDirName(title, fileId) {
+    return `${compactSegment(title)}-${shortHash(fileId)}`;
+}
+async function listFolderFiles(drive, folderId, recursive, parents = []) {
+    const q = driveFolderChildrenQuery(folderId);
+    const docs = [];
+    const skipped = [];
+    let pageToken;
+    do {
+        const page = await drive.listFiles({ q, pageToken });
+        for (const file of page.files) {
+            if (file.mimeType === GDRIVE_FOLDER_MIME_TYPE) {
+                if (recursive) {
+                    const nested = await listFolderFiles(drive, file.id, true, [...parents, file.name]);
+                    docs.push(...nested.docs);
+                    skipped.push(...nested.skipped);
+                }
+                continue;
+            }
+            if (file.mimeType !== GDRIVE_DOC_MIME_TYPE) {
+                skipped.push({ externalId: file.id, reason: `unsupported mime type: ${file.mimeType}` });
+                continue;
+            }
+            docs.push({ file, drivePath: parents, folderId });
+        }
+        pageToken = page.nextPageToken ?? undefined;
+    } while (pageToken);
+    return { docs, skipped };
+}
+export async function fetchGdriveSnapshot(params) {
+    await mkdir(params.stagedDir, { recursive: true });
+    const clients = createGoogleDocsClients(params.key);
+    const { docs, skipped } = await listFolderFiles(clients.drive, params.config.folderId, params.config.recursive);
+    for (const { file, drivePath, folderId } of docs) {
+        const document = await clients.docs.getDocument(file.id);
+        const title = (document.title?.trim() || file.name).trim();
+        const relDir = join('docs', ...drivePath.map((segment) => compactSegment(segment)), gdriveDocDirName(title, file.id));
+        const markdownBody = normalizeGoogleDocToMarkdown(document);
+        const pageMarkdown = [`# ${title}`, markdownBody].filter(Boolean).join('\n\n');
+        await writeJson(join(params.stagedDir, relDir, 'metadata.json'), {
+            id: file.id,
+            title,
+            path: [...drivePath, title].join(' / ') || title,
+            url: file.webViewLink,
+            mimeType: file.mimeType,
+            folderId,
+            drivePath,
+            modifiedTime: file.modifiedTime,
+        });
+        await writeText(join(params.stagedDir, relDir, 'page.md'), pageMarkdown);
+    }
+    const manifest = {
+        source: GDRIVE_SOURCE_KEY,
+        folderId: params.config.folderId,
+        recursive: params.config.recursive,
+        fetchedAt: new Date().toISOString(),
+        fileCount: docs.length,
+        skipped,
+        warnings: skipped.length > 0
+            ? [`Skipped ${skipped.length} non-Google-Doc file(s); only Google Docs are ingested in v1.`]
+            : [],
+    };
+    await writeJson(join(params.stagedDir, 'manifest.json'), manifest);
+    return manifest;
+}

package/dist/context/ingest/adapters/gdrive/gdrive-client.d.ts

@@ -0,0 +1,30 @@
+import type { GdriveFileRecord, GoogleDocsDocument } from './types.js';
+export interface GoogleDriveClient {
+    listFiles(args: {
+        q: string;
+        pageToken?: string;
+    }): Promise<{
+        files: GdriveFileRecord[];
+        nextPageToken: string | null;
+    }>;
+    getFile(fileId: string): Promise<GdriveFileRecord | null>;
+}
+export interface GoogleDocsClients {
+    drive: GoogleDriveClient;
+    docs: {
+        getDocument(documentId: string): Promise<GoogleDocsDocument>;
+    };
+}
+/** @internal Retries transient Google API responses (429/5xx) honoring Retry-After. */
+export declare function fetchWithGoogleRetry(doFetch: () => Promise<Response>, options?: {
+    maxAttempts?: number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<Response>;
+/** Builds the Drive query for the non-trashed direct children of a folder, escaping the folder id. */
+export declare function driveFolderChildrenQuery(folderId: string): string;
+/**
+ * Confirms `folderId` resolves to a folder the service account can read, then counts the
+ * Google Docs directly inside it. Throws a caller-facing error when the id is missing or not a folder.
+ */
+export declare function verifyGdriveFolderAndCountDocs(drive: GoogleDriveClient, folderId: string): Promise<number>;
+export declare function createGoogleDocsClients(rawKey: unknown): GoogleDocsClients;

package/dist/context/ingest/adapters/gdrive/gdrive-client.js

@@ -0,0 +1,132 @@
+import { JWT } from 'google-auth-library';
+import { GDRIVE_DOC_MIME_TYPE, GDRIVE_FOLDER_MIME_TYPE, GDRIVE_SCOPES, gdriveServiceAccountKeySchema } from './types.js';
+const GOOGLE_DRIVE_BASE_URL = 'https://www.googleapis.com/drive/v3';
+const GOOGLE_DOCS_BASE_URL = 'https://docs.googleapis.com/v1';
+const GOOGLE_FILE_FIELDS = 'id,name,mimeType,parents,webViewLink,modifiedTime';
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+const MAX_REQUEST_ATTEMPTS = 4;
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryDelayMs(attempt, retryAfterHeader) {
+    const retryAfterSeconds = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : Number.NaN;
+    if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0) {
+        return Math.min(retryAfterSeconds * 1000, 30_000);
+    }
+    return Math.min(500 * 2 ** attempt, 8_000);
+}
+/** @internal Retries transient Google API responses (429/5xx) honoring Retry-After. */
+export async function fetchWithGoogleRetry(doFetch, options = {}) {
+    const maxAttempts = options.maxAttempts ?? MAX_REQUEST_ATTEMPTS;
+    const sleep = options.sleep ?? defaultSleep;
+    let response = await doFetch();
+    for (let attempt = 1; attempt < maxAttempts && !response.ok && RETRYABLE_STATUSES.has(response.status); attempt += 1) {
+        await sleep(retryDelayMs(attempt - 1, response.headers.get('retry-after')));
+        response = await doFetch();
+    }
+    return response;
+}
+async function parseGoogleResponse(response) {
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Google API request failed (${response.status}): ${body || response.statusText}`);
+    }
+    return (await response.json());
+}
+async function authorizedFetch(client, url) {
+    return fetchWithGoogleRetry(async () => {
+        const headers = await client.getRequestHeaders(url);
+        return fetch(url, { headers });
+    });
+}
+function isGoogleApiFileRecord(file) {
+    return typeof file.id === 'string' && typeof file.name === 'string' && typeof file.mimeType === 'string';
+}
+function toFileRecord(file) {
+    return {
+        id: file.id,
+        name: file.name,
+        mimeType: file.mimeType,
+        parents: Array.isArray(file.parents) ? file.parents.filter((parent) => typeof parent === 'string') : [],
+        webViewLink: typeof file.webViewLink === 'string' ? file.webViewLink : null,
+        modifiedTime: typeof file.modifiedTime === 'string' ? file.modifiedTime : null,
+    };
+}
+function escapeDriveQueryValue(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/** Builds the Drive query for the non-trashed direct children of a folder, escaping the folder id. */
+export function driveFolderChildrenQuery(folderId) {
+    return `'${escapeDriveQueryValue(folderId)}' in parents and trashed = false`;
+}
+/**
+ * Confirms `folderId` resolves to a folder the service account can read, then counts the
+ * Google Docs directly inside it. Throws a caller-facing error when the id is missing or not a folder.
+ */
+export async function verifyGdriveFolderAndCountDocs(drive, folderId) {
+    const folder = await drive.getFile(folderId);
+    if (!folder) {
+        throw new Error(`Google Drive folder "${folderId}" is not accessible. Share it with the service account email and verify folder_id.`);
+    }
+    if (folder.mimeType !== GDRIVE_FOLDER_MIME_TYPE) {
+        throw new Error(`Google Drive id "${folderId}" is not a folder (mimeType: ${folder.mimeType}).`);
+    }
+    const q = driveFolderChildrenQuery(folderId);
+    let docs = 0;
+    let pageToken;
+    do {
+        const page = await drive.listFiles({ q, pageToken });
+        docs += page.files.filter((file) => file.mimeType === GDRIVE_DOC_MIME_TYPE).length;
+        pageToken = page.nextPageToken ?? undefined;
+    } while (pageToken);
+    return docs;
+}
+export function createGoogleDocsClients(rawKey) {
+    const key = gdriveServiceAccountKeySchema.parse(rawKey);
+    const client = new JWT({
+        email: key.client_email,
+        key: key.private_key,
+        scopes: [...GDRIVE_SCOPES],
+    });
+    return {
+        drive: {
+            async listFiles(args) {
+                const params = new URLSearchParams({
+                    q: args.q,
+                    supportsAllDrives: 'true',
+                    includeItemsFromAllDrives: 'true',
+                    pageSize: '1000',
+                    fields: `nextPageToken,files(${GOOGLE_FILE_FIELDS})`,
+                });
+                if (args.pageToken) {
+                    params.set('pageToken', args.pageToken);
+                }
+                const response = await authorizedFetch(client, `${GOOGLE_DRIVE_BASE_URL}/files?${params.toString()}`);
+                const parsed = await parseGoogleResponse(response);
+                return {
+                    files: (parsed.files ?? []).filter(isGoogleApiFileRecord).map(toFileRecord),
+                    nextPageToken: typeof parsed.nextPageToken === 'string' ? parsed.nextPageToken : null,
+                };
+            },
+            async getFile(fileId) {
+                const params = new URLSearchParams({ supportsAllDrives: 'true', fields: GOOGLE_FILE_FIELDS });
+                const response = await authorizedFetch(client, `${GOOGLE_DRIVE_BASE_URL}/files/${encodeURIComponent(fileId)}?${params.toString()}`);
+                if (response.status === 404) {
+                    return null;
+                }
+                const file = await parseGoogleResponse(response);
+                return isGoogleApiFileRecord(file) ? toFileRecord(file) : null;
+            },
+        },
+        docs: {
+            async getDocument(documentId) {
+                const params = new URLSearchParams({
+                    includeTabsContent: 'true',
+                    suggestionsViewMode: 'PREVIEW_WITHOUT_SUGGESTIONS',
+                });
+                const response = await authorizedFetch(client, `${GOOGLE_DOCS_BASE_URL}/documents/${documentId}?${params.toString()}`);
+                return await parseGoogleResponse(response);
+            },
+        },
+    };
+}

package/dist/context/ingest/adapters/gdrive/gdrive.adapter.d.ts

@@ -0,0 +1,11 @@
+import type { ChunkResult, DiffSet, FetchContext, ScopeDescriptor, SourceAdapter } from '../../types.js';
+export declare class GdriveSourceAdapter implements SourceAdapter {
+    readonly source = "gdrive";
+    readonly skillNames: string[];
+    readonly reconcileSkillNames: string[];
+    readonly evidenceIndexing: "documents";
+    detect(stagedDir: string): Promise<boolean>;
+    fetch(pullConfig: unknown, stagedDir: string, _ctx: FetchContext): Promise<void>;
+    chunk(stagedDir: string, diffSet?: DiffSet): Promise<ChunkResult>;
+    describeScope(stagedDir: string): Promise<ScopeDescriptor>;
+}

package/dist/context/ingest/adapters/gdrive/gdrive.adapter.js

@@ -0,0 +1,27 @@
+import { chunkGdriveStagedDir, describeGdriveScope } from './chunk.js';
+import { detectGdriveStagedDir } from './detect.js';
+import { fetchGdriveSnapshot } from './fetch.js';
+import { gdrivePullConfigSchema } from './types.js';
+export class GdriveSourceAdapter {
+    source = 'gdrive';
+    skillNames = ['gdrive_synthesize'];
+    reconcileSkillNames = [];
+    evidenceIndexing = 'documents';
+    detect(stagedDir) {
+        return detectGdriveStagedDir(stagedDir);
+    }
+    async fetch(pullConfig, stagedDir, _ctx) {
+        const config = gdrivePullConfigSchema.parse(pullConfig);
+        await fetchGdriveSnapshot({
+            key: JSON.parse(config.serviceAccountKey),
+            config,
+            stagedDir,
+        });
+    }
+    chunk(stagedDir, diffSet) {
+        return chunkGdriveStagedDir(stagedDir, diffSet);
+    }
+    describeScope(stagedDir) {
+        return describeGdriveScope(stagedDir);
+    }
+}

package/dist/context/ingest/adapters/gdrive/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { GoogleDocsDocument } from './types.js';
+export declare function normalizeGoogleDocToMarkdown(document: GoogleDocsDocument): string;