@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/utils/error-display.js

@@ -0,0 +1,314 @@
+import { AppError, ProviderError } from '../types/errors.js';
+const MAX_ERROR_LENGTH = 240;
+const NETWORK_ERROR_PATTERNS = [
+    {
+        pattern: /ECONNREFUSED/i,
+        category: 'network',
+        message: (provider) => `Cannot connect to ${provider ?? 'the provider'}. Check whether the service is reachable.`,
+    },
+    {
+        pattern: /ETIMEDOUT|ECONNABORTED|timed?[\s_-]?out/i,
+        category: 'timeout',
+        message: () => 'Connection timed out before the request completed.',
+    },
+    {
+        pattern: /ENOTFOUND|EAI_AGAIN/i,
+        category: 'network',
+        message: (provider) => `DNS lookup failed for ${provider ?? 'the provider'}. Check the base URL and network.`,
+    },
+];
+function truncateMessage(msg) {
+    if (msg.length <= MAX_ERROR_LENGTH)
+        return msg;
+    return msg.slice(0, MAX_ERROR_LENGTH) + '\u2026';
+}
+function extractStringField(record, key) {
+    const value = record[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function extractStructuredMessage(msg) {
+    const trimmed = msg.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!parsed || typeof parsed !== 'object')
+            return undefined;
+        const record = parsed;
+        const nestedError = record.error && typeof record.error === 'object' ? record.error : undefined;
+        const parts = [
+            extractStringField(record, 'message'),
+            nestedError ? extractStringField(nestedError, 'message') : undefined,
+            nestedError ? extractStringField(nestedError, 'code') : undefined,
+            nestedError ? extractStringField(nestedError, 'type') : undefined,
+            extractStringField(record, 'code'),
+            extractStringField(record, 'type'),
+        ].filter((value) => Boolean(value));
+        return parts.length > 0 ? parts.join(', ') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripJson(msg) {
+    return msg
+        .replace(/\{[^{}]{0,500}\}/g, ' ')
+        .replace(/\[[^\[\]]{0,500}\]/g, ' ')
+        .replace(/\s{2,}/g, ' ')
+        .trim();
+}
+function cleanMessage(msg, fallbackMessage) {
+    const structured = extractStructuredMessage(msg);
+    if (structured)
+        return truncateMessage(structured);
+    const stripped = stripJson(msg);
+    if (stripped.length > 0)
+        return truncateMessage(stripped);
+    if (msg.trim().length > 0)
+        return truncateMessage(msg.trim());
+    return fallbackMessage ?? 'Unexpected error';
+}
+function inferCategory(message, statusCode) {
+    const msg = message.toLowerCase();
+    if (statusCode === 401)
+        return 'authentication';
+    if (statusCode === 402)
+        return 'billing';
+    if (statusCode === 403)
+        return 'authorization';
+    if (statusCode === 404)
+        return 'not_found';
+    if (statusCode === 408)
+        return 'timeout';
+    if (statusCode === 429)
+        return 'rate_limit';
+    if (statusCode === 400)
+        return 'bad_request';
+    if (statusCode !== undefined && statusCode >= 500)
+        return 'service';
+    if (/api[_\s-]?key|auth|token|credential|jwt|unauthoriz/.test(msg))
+        return 'authentication';
+    if (/forbidden|access denied|permission denied|not allowed/.test(msg))
+        return 'authorization';
+    if (/billing|payment required|credits?|quota|depleted|insufficient balance/.test(msg))
+        return 'billing';
+    if (/rate.limit|too many requests|throttl/.test(msg))
+        return 'rate_limit';
+    if (/timed?[\s_-]?out|etimedout|deadline exceeded/.test(msg))
+        return 'timeout';
+    if (/econnrefused|enotfound|ehostunreach|econnreset|socket hang up|fetch failed|dns|tls|ssl|certificate/.test(msg))
+        return 'network';
+    if (/not found|unknown model|no such model|unsupported model|unknown endpoint/.test(msg))
+        return 'not_found';
+    if (/invalid request|bad request|invalid argument|schema|malformed|unsupported parameter/.test(msg))
+        return 'bad_request';
+    if (/invalid json|parse|no response body|unexpected eof|stream ended|malformed response/.test(msg))
+        return 'protocol';
+    return 'unknown';
+}
+function inferHint(category, statusCode) {
+    switch (category) {
+        case 'rate_limit':
+            return 'The caller may retry automatically. If this persists, wait, lower request volume, or switch models/providers.';
+        case 'authentication':
+            return 'Possible causes: invalid or expired credentials, missing subscription/session state, account restrictions, or the wrong provider/endpoint receiving the request.';
+        case 'authorization':
+            return 'Possible causes: missing model access, account permissions, safety/policy restrictions, or provider routing to a service that does not expose this model.';
+        case 'billing':
+            return 'Check credits, subscription status, usage limits, or account entitlements.';
+        case 'timeout':
+            return 'Check network stability, provider latency, and request size.';
+        case 'network':
+            return 'Check connectivity, DNS, TLS certificates, base URL, or any local proxy/tunnel.';
+        case 'bad_request':
+            return 'Check model id, parameters, message format, and tool schema.';
+        case 'not_found':
+            return 'Check model id, provider selection, and API path.';
+        case 'protocol':
+            return 'Check upstream compatibility, streaming mode, and transport stability.';
+        case 'service':
+            return statusCode === 503
+                ? 'The provider is temporarily unavailable. Retry shortly or switch providers if the issue persists.'
+                : 'The provider returned a server-side failure. Retry shortly or switch providers if the issue persists.';
+        default:
+            return undefined;
+    }
+}
+function inferSource(error, override) {
+    if (override)
+        return override;
+    if (error instanceof AppError && error.source)
+        return error.source;
+    if (error instanceof Error && error.name === 'TypeError' && /fetch/i.test(error.message))
+        return 'transport';
+    return 'unknown';
+}
+function buildSummary(message, metadata) {
+    const tags = [];
+    if (metadata.phase && !message.toLowerCase().includes(metadata.phase.toLowerCase()))
+        tags.push(`phase=${metadata.phase}`);
+    if (metadata.providerCode && !message.includes(metadata.providerCode))
+        tags.push(`code=${metadata.providerCode}`);
+    if (metadata.requestId && !message.includes(metadata.requestId))
+        tags.push(`request_id=${metadata.requestId}`);
+    return tags.length > 0 ? `${message} (${tags.join(', ')})` : message;
+}
+function getNetworkErrorMessage(message, provider) {
+    for (const entry of NETWORK_ERROR_PATTERNS) {
+        if (entry.pattern.test(message)) {
+            return {
+                category: entry.category,
+                summary: entry.message(provider),
+            };
+        }
+    }
+    return undefined;
+}
+function extractErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const message = extractStringField(error, 'message');
+        if (message)
+            return message;
+    }
+    return String(error);
+}
+export function normalizeError(error, options = {}) {
+    const rawMessage = extractErrorMessage(error);
+    const statusCode = error instanceof AppError
+        ? error.statusCode
+        : error && typeof error === 'object' && 'statusCode' in error && typeof error.statusCode === 'number'
+            ? error.statusCode
+            : error && typeof error === 'object' && 'status' in error && typeof error.status === 'number'
+                ? error.status
+                : undefined;
+    const provider = options.provider ?? (error instanceof AppError ? error.provider : undefined);
+    const cleanedMessage = cleanMessage(rawMessage, options.fallbackMessage);
+    const network = getNetworkErrorMessage(rawMessage, provider);
+    const category = error instanceof AppError && error.category
+        ? error.category
+        : network?.category ?? inferCategory(cleanedMessage, statusCode);
+    const source = inferSource(error, options.source);
+    const summary = buildSummary(network?.summary ?? cleanedMessage, {
+        requestId: error instanceof AppError ? error.requestId : undefined,
+        providerCode: error instanceof AppError ? error.providerCode : undefined,
+        phase: error instanceof AppError ? error.phase : undefined,
+    });
+    const hint = error instanceof AppError && error.guidance
+        ? error.guidance
+        : inferHint(category, statusCode);
+    return {
+        name: error instanceof Error ? error.name : 'Error',
+        message: cleanedMessage,
+        summary,
+        ...(hint ? { hint } : {}),
+        ...(error instanceof AppError ? { code: error.code } : {}),
+        category,
+        source,
+        recoverable: error instanceof AppError ? error.recoverable : false,
+        ...(statusCode !== undefined ? { statusCode } : {}),
+        ...(provider ? { provider } : {}),
+        ...(error instanceof AppError && error.operation ? { operation: error.operation } : {}),
+        ...(error instanceof AppError && error.phase ? { phase: error.phase } : {}),
+        ...(error instanceof AppError && error.requestId ? { requestId: error.requestId } : {}),
+        ...(error instanceof AppError && error.providerCode ? { providerCode: error.providerCode } : {}),
+        ...(error instanceof AppError && error.providerType ? { providerType: error.providerType } : {}),
+        ...(error instanceof AppError && error.retryAfterMs !== undefined ? { retryAfterMs: error.retryAfterMs } : {}),
+    };
+}
+export function summarizeError(error, options = {}) {
+    return normalizeError(error, options).summary;
+}
+export function formatError(error, options = {}) {
+    const normalized = normalizeError(error, options);
+    const lines = [normalized.summary];
+    if (normalized.hint) {
+        lines.push(`  Hint: ${normalized.hint}`);
+    }
+    if (normalized.retryAfterMs !== undefined) {
+        lines.push(`  Retry in ${Math.ceil(normalized.retryAfterMs / 1000)}s`);
+    }
+    return lines.join('\n');
+}
+export function buildErrorResponseBody(error, options = {}) {
+    const normalized = normalizeError(error, options);
+    return {
+        error: normalized.summary,
+        ...(normalized.hint ? { hint: normalized.hint } : {}),
+        ...(normalized.code ? { code: normalized.code } : {}),
+        category: normalized.category,
+        source: normalized.source,
+        recoverable: normalized.recoverable,
+        ...(normalized.statusCode !== undefined ? { status: normalized.statusCode } : {}),
+        ...(normalized.provider ? { provider: normalized.provider } : {}),
+        ...(normalized.operation ? { operation: normalized.operation } : {}),
+        ...(normalized.phase ? { phase: normalized.phase } : {}),
+        ...(normalized.requestId ? { requestId: normalized.requestId } : {}),
+        ...(normalized.providerCode ? { providerCode: normalized.providerCode } : {}),
+        ...(normalized.providerType ? { providerType: normalized.providerType } : {}),
+        ...(normalized.retryAfterMs !== undefined ? { retryAfterMs: normalized.retryAfterMs } : {}),
+    };
+}
+export function toProviderError(error, options = {}) {
+    if (error instanceof ProviderError) {
+        return new ProviderError(error.message, {
+            statusCode: error.statusCode ?? options.statusCode,
+            category: error.category ?? options.category,
+            guidance: error.guidance ?? options.guidance,
+            detail: error.detail ?? options.detail,
+            source: 'provider',
+            provider: error.provider ?? options.provider,
+            operation: error.operation ?? options.operation,
+            phase: error.phase ?? options.phase,
+            requestId: error.requestId ?? options.requestId,
+            providerCode: error.providerCode ?? options.providerCode,
+            providerType: error.providerType ?? options.providerType,
+            retryAfterMs: error.retryAfterMs ?? options.retryAfterMs,
+            rawMessage: error.rawMessage ?? options.rawMessage ?? error.message,
+        });
+    }
+    const normalized = normalizeError(error, {
+        provider: options.provider,
+        fallbackMessage: options.fallbackMessage,
+        source: 'provider',
+    });
+    return new ProviderError(normalized.message, {
+        ...(options.statusCode !== undefined || normalized.statusCode !== undefined
+            ? { statusCode: options.statusCode ?? normalized.statusCode }
+            : {}),
+        ...(options.category
+            ? { category: options.category }
+            : normalized.category !== 'unknown'
+                ? { category: normalized.category }
+                : {}),
+        ...(options.guidance
+            ? { guidance: options.guidance }
+            : normalized.hint
+                ? { guidance: normalized.hint }
+                : {}),
+        ...(options.detail ? { detail: options.detail } : {}),
+        source: 'provider',
+        ...(options.provider ?? normalized.provider ? { provider: options.provider ?? normalized.provider } : {}),
+        ...(options.operation ? { operation: options.operation } : {}),
+        ...(options.phase ? { phase: options.phase } : {}),
+        ...(options.requestId ?? normalized.requestId ? { requestId: options.requestId ?? normalized.requestId } : {}),
+        ...(options.providerCode ?? normalized.providerCode ? { providerCode: options.providerCode ?? normalized.providerCode } : {}),
+        ...(options.providerType ?? normalized.providerType ? { providerType: options.providerType ?? normalized.providerType } : {}),
+        ...(options.retryAfterMs ?? normalized.retryAfterMs !== undefined
+            ? { retryAfterMs: options.retryAfterMs ?? normalized.retryAfterMs }
+            : {}),
+        ...(options.rawMessage
+            ? { rawMessage: options.rawMessage }
+            : typeof error === 'string'
+                ? { rawMessage: error }
+                : error instanceof Error
+                    ? { rawMessage: error.message }
+                    : {}),
+    });
+}
+export function formatProviderError(error, provider) {
+    return formatError(error, { provider, source: 'provider' });
+}

package/dist/platform/utils/glob-to-regex.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared glob-to-regex conversion utility.
+ * Handles **, *, and ? wildcards correctly for file path matching.
+ */
+export declare function buildGlobMatcher(glob: string): (path: string) => boolean;
+export declare function globToRegex(glob: string): RegExp;
+//# sourceMappingURL=glob-to-regex.d.ts.map

package/dist/platform/utils/glob-to-regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob-to-regex.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/glob-to-regex.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAGxE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoBhD"}

package/dist/platform/utils/glob-to-regex.js

@@ -0,0 +1,30 @@
+/**
+ * Shared glob-to-regex conversion utility.
+ * Handles **, *, and ? wildcards correctly for file path matching.
+ */
+export function buildGlobMatcher(glob) {
+    const regex = globToRegex(glob);
+    return (path) => regex.test(path.replace(/\\/g, '/'));
+}
+export function globToRegex(glob) {
+    // Escape regex special chars character-by-character to avoid TS regex literal
+    // parsing issues with character classes.
+    const specials = new Set(['.', '+', '^', '$', '{', '}', '(', ')', '|', '[', ']', '\\']);
+    let escaped = '';
+    for (const ch of glob) {
+        if (specials.has(ch)) {
+            escaped += '\\' + ch;
+        }
+        else {
+            escaped += ch;
+        }
+    }
+    // Handle glob wildcards (order matters: ** before *)
+    escaped = escaped
+        .replace(/\*/g, '__STAR__')
+        .replace(/__STAR____STAR__\//g, '(?:.+/)?') // **/ => any path prefix
+        .replace(/__STAR____STAR__/g, '.+') // **  => any chars
+        .replace(/__STAR__/g, '[^/]*') // *   => filename chars only
+        .replace(/\?/g, '[^/]'); // ?   => single non-slash char
+    return new RegExp(`(^|/)${escaped}$`);
+}

package/dist/platform/utils/logger.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ActivityLogger — Persistent debug logger for GoodVibes.
+ * Writes to .goodvibes/logs/activity.md
+ *
+ * Uses a buffered async writer to avoid blocking the event loop on every
+ * log entry. Entries are flushed when the buffer reaches LOG_BUFFER_MAX
+ * or after LOG_FLUSH_INTERVAL_MS, whichever comes first.
+ */
+declare class ActivityLogger {
+    private logPath;
+    private buffer;
+    private flushTimer;
+    configure(logDir: string): void;
+    private scheduleFlush;
+    private flush;
+    private write;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    debug(message: string, data?: Record<string, unknown>): void;
+}
+export declare const logger: ActivityLogger;
+export declare function configureActivityLogger(logDir: string): void;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/platform/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/logger.ts"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,UAAU,CAA8C;IAEhE,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAU/B,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,KAAK;IAab,OAAO,CAAC,KAAK;IAmBb,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACrD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CACtD;AAED,eAAO,MAAM,MAAM,gBAAuB,CAAC;AAE3C,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE5D"}

package/dist/platform/utils/logger.js

@@ -0,0 +1,74 @@
+import { appendFile, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+/** Maximum buffered entries before a flush is triggered. */
+const LOG_BUFFER_MAX = 10;
+/** Flush interval in milliseconds when buffer is below max. */
+const LOG_FLUSH_INTERVAL_MS = 100;
+/**
+ * ActivityLogger — Persistent debug logger for GoodVibes.
+ * Writes to .goodvibes/logs/activity.md
+ *
+ * Uses a buffered async writer to avoid blocking the event loop on every
+ * log entry. Entries are flushed when the buffer reaches LOG_BUFFER_MAX
+ * or after LOG_FLUSH_INTERVAL_MS, whichever comes first.
+ */
+class ActivityLogger {
+    logPath = null;
+    buffer = [];
+    flushTimer = null;
+    configure(logDir) {
+        if (!existsSync(logDir)) {
+            mkdirSync(logDir, { recursive: true });
+        }
+        this.logPath = join(logDir, 'activity.md');
+        if (this.buffer.length > 0) {
+            this.flush();
+        }
+    }
+    scheduleFlush() {
+        if (this.flushTimer !== null)
+            return;
+        this.flushTimer = setTimeout(() => this.flush(), LOG_FLUSH_INTERVAL_MS);
+    }
+    flush() {
+        this.flushTimer = null;
+        if (this.buffer.length === 0)
+            return;
+        if (!this.logPath)
+            return;
+        const chunk = this.buffer.splice(0).join('');
+        appendFile(this.logPath, chunk, (err) => {
+            if (err) {
+                // Best-effort: cannot log the logger's own error without recursion
+                process.stderr.write(`[ActivityLogger] flush error: ${err.message}\n`);
+            }
+        });
+    }
+    write(level, message, data) {
+        const timestamp = new Date().toISOString();
+        let entry = `[${timestamp}] [${level}] ${message}\n`;
+        if (data) {
+            entry += '```json\n' + JSON.stringify(data, null, 2) + '\n```\n';
+        }
+        this.buffer.push(entry);
+        if (this.buffer.length >= LOG_BUFFER_MAX) {
+            // Buffer full — flush immediately without waiting for the timer
+            if (this.flushTimer !== null) {
+                clearTimeout(this.flushTimer);
+                this.flushTimer = null;
+            }
+            this.flush();
+        }
+        else {
+            this.scheduleFlush();
+        }
+    }
+    info(message, data) { this.write('INFO', message, data); }
+    warn(message, data) { this.write('WARN', message, data); }
+    error(message, data) { this.write('ERROR', message, data); }
+    debug(message, data) { this.write('DEBUG', message, data); }
+}
+export const logger = new ActivityLogger();
+export function configureActivityLogger(logDir) {
+    logger.configure(logDir);
+}

package/dist/platform/utils/markdown-disclosure.d.ts

@@ -0,0 +1,23 @@
+export type MarkdownFrontmatterValue = string | string[];
+export interface MarkdownFrontmatter {
+    readonly [key: string]: MarkdownFrontmatterValue | undefined;
+}
+export interface MarkdownDisclosure {
+    readonly path: string;
+    readonly metadata: MarkdownFrontmatter;
+    readonly body: string;
+    readonly includes: readonly string[];
+    readonly sections: readonly string[];
+    readonly preview: string;
+}
+export declare function parseMarkdownFrontmatter(content: string): {
+    metadata: MarkdownFrontmatter;
+    body: string;
+};
+export declare function normalizeFrontmatterList(value: MarkdownFrontmatterValue | undefined): string[];
+export declare function collectMarkdownReferences(body: string): string[];
+export declare function extractMarkdownSections(body: string): string[];
+export declare function extractMarkdownPreview(body: string, maxChars?: number): string;
+export declare function readMarkdownDisclosure(filePath: string): MarkdownDisclosure;
+export declare function materializeMarkdownBody(filePath: string, body?: string): string;
+//# sourceMappingURL=markdown-disclosure.d.ts.map

package/dist/platform/utils/markdown-disclosure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-disclosure.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/markdown-disclosure.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS,CAAC;CAC9D;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAID,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG;IACzD,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd,CAiBA;AAkED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,wBAAwB,GAAG,SAAS,GAAG,MAAM,EAAE,CAI9F;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQhE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ9D;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAM,GAAG,MAAM,CAY3E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAY3E;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAI/E"}

package/dist/platform/utils/markdown-disclosure.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+const MAX_INCLUDE_DEPTH = 5;
+export function parseMarkdownFrontmatter(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith('---')) {
+        return { metadata: {}, body: content };
+    }
+    const secondDash = trimmed.indexOf('\n---', 3);
+    if (secondDash === -1) {
+        return { metadata: {}, body: content };
+    }
+    const rawFrontmatter = trimmed.slice(3, secondDash).trim();
+    const body = trimmed.slice(secondDash + 4).trimStart();
+    return {
+        metadata: parseSimpleYamlFrontmatter(rawFrontmatter),
+        body,
+    };
+}
+function parseSimpleYamlFrontmatter(frontmatter) {
+    const result = {};
+    const lines = frontmatter.split('\n');
+    let currentKey = null;
+    let listBuffer = [];
+    let collectingList = false;
+    const flushList = () => {
+        if (collectingList && currentKey) {
+            result[currentKey] = listBuffer.slice();
+        }
+        collectingList = false;
+        currentKey = null;
+        listBuffer = [];
+    };
+    for (const line of lines) {
+        if (!line.trim() || line.trim().startsWith('#')) {
+            if (collectingList)
+                flushList();
+            continue;
+        }
+        const listItem = line.match(/^\s+-\s+(.+)$/);
+        if (collectingList && listItem) {
+            listBuffer.push(stripWrappingQuotes(listItem[1].trim()));
+            continue;
+        }
+        const kv = line.match(/^([\w.-]+):\s*(.*)$/);
+        if (!kv)
+            continue;
+        if (collectingList)
+            flushList();
+        currentKey = kv[1];
+        const rawValue = kv[2].trim();
+        if (!rawValue) {
+            collectingList = true;
+            continue;
+        }
+        const inlineList = rawValue.match(/^\[(.*)\]$/);
+        if (inlineList) {
+            result[currentKey] = inlineList[1]
+                .split(',')
+                .map((part) => stripWrappingQuotes(part.trim()))
+                .filter(Boolean);
+            currentKey = null;
+            continue;
+        }
+        result[currentKey] = stripWrappingQuotes(rawValue);
+        currentKey = null;
+    }
+    if (collectingList)
+        flushList();
+    return result;
+}
+function stripWrappingQuotes(value) {
+    return value.replace(/^['"]|['"]$/g, '');
+}
+export function normalizeFrontmatterList(value) {
+    if (!value)
+        return [];
+    if (Array.isArray(value))
+        return value.map((entry) => entry.trim()).filter(Boolean);
+    return value.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+export function collectMarkdownReferences(body) {
+    const refs = [];
+    const refRegex = /^\s*@([A-Za-z0-9_./#-]+)\s*$/gm;
+    let match;
+    while ((match = refRegex.exec(body)) !== null) {
+        refs.push(match[1]);
+    }
+    return refs;
+}
+export function extractMarkdownSections(body) {
+    const sections = [];
+    const headingRegex = /^\s{0,3}(#{1,6})\s+(.+?)\s*$/gm;
+    let match;
+    while ((match = headingRegex.exec(body)) !== null) {
+        sections.push(match[2].trim());
+    }
+    return sections;
+}
+export function extractMarkdownPreview(body, maxChars = 220) {
+    const cleaned = body
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('@') && !line.startsWith('#'))
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!cleaned)
+        return '';
+    if (cleaned.length <= maxChars)
+        return cleaned;
+    return `${cleaned.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+export function readMarkdownDisclosure(filePath) {
+    const resolvedPath = resolve(filePath);
+    const raw = readFileSync(resolvedPath, 'utf-8');
+    const { metadata, body } = parseMarkdownFrontmatter(raw);
+    return {
+        path: resolvedPath,
+        metadata,
+        body,
+        includes: collectMarkdownReferences(body),
+        sections: extractMarkdownSections(body),
+        preview: extractMarkdownPreview(body),
+    };
+}
+export function materializeMarkdownBody(filePath, body) {
+    const resolvedPath = resolve(filePath);
+    const sourceBody = body ?? readMarkdownDisclosure(resolvedPath).body;
+    return resolveMarkdownIncludes(resolvedPath, sourceBody, new Set(), 0);
+}
+function resolveMarkdownIncludes(sourcePath, body, visited, depth) {
+    if (depth >= MAX_INCLUDE_DEPTH)
+        return '';
+    const resolvedSourcePath = resolve(sourcePath);
+    if (visited.has(resolvedSourcePath))
+        return '';
+    visited.add(resolvedSourcePath);
+    const baseDir = dirname(resolvedSourcePath);
+    const lines = body.split('\n');
+    const result = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('@@')) {
+            const marker = line.indexOf('@@');
+            result.push(`${line.slice(0, marker)}${line.slice(marker + 1)}`);
+            continue;
+        }
+        const includeMatch = trimmed.match(/^@([A-Za-z0-9_./#-]+)\s*$/);
+        if (!includeMatch) {
+            result.push(line);
+            continue;
+        }
+        const includeTarget = includeMatch[1];
+        const includePath = resolve(baseDir, includeTarget.split('#')[0]);
+        if (!existsSync(includePath)) {
+            continue;
+        }
+        const included = readMarkdownDisclosure(includePath);
+        const materialized = resolveMarkdownIncludes(includePath, included.body, visited, depth + 1);
+        if (!materialized)
+            continue;
+        result.push(materialized);
+    }
+    return result.join('\n');
+}

package/dist/platform/utils/notebook.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared notebook utility — checks whether a file path targets a Jupyter notebook.
+ * Case-insensitive to handle `.IPYNB`, `.Ipynb`, etc.
+ */
+export declare function isNotebookFile(filePath: string): boolean;
+//# sourceMappingURL=notebook.d.ts.map

package/dist/platform/utils/notebook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notebook.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/notebook.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/platform/utils/notebook.js

@@ -0,0 +1,7 @@
+/**
+ * Shared notebook utility — checks whether a file path targets a Jupyter notebook.
+ * Case-insensitive to handle `.IPYNB`, `.Ipynb`, etc.
+ */
+export function isNotebookFile(filePath) {
+    return filePath.toLowerCase().endsWith('.ipynb');
+}