@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/state/kv-state.js

@@ -0,0 +1,215 @@
+import { existsSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../utils/logger.js';
+import { randomBytes } from 'crypto';
+import { JsonFileStore } from './json-file-store.js';
+import { summarizeError } from '../utils/error-display.js';
+/**
+ * Reserved keys that cannot be set by callers.
+ */
+const RESERVED_KEYS = new Set(['id', 'started_at', '__proto__', 'constructor', 'prototype']);
+function resolveLegacyStateDir(storageRoot) {
+    if (!storageRoot) {
+        throw new Error('KVState requires an explicit stateDir or storageRoot');
+    }
+    return join(storageRoot, '.goodvibes', 'state');
+}
+function resolveKVStateOptions(sessionIdOrOptions, storageRoot) {
+    if (typeof sessionIdOrOptions === 'object' && sessionIdOrOptions !== null) {
+        if (!sessionIdOrOptions.stateDir || sessionIdOrOptions.stateDir.trim().length === 0) {
+            throw new Error('KVState requires a non-empty stateDir');
+        }
+        return sessionIdOrOptions;
+    }
+    return {
+        sessionId: sessionIdOrOptions,
+        stateDir: resolveLegacyStateDir(storageRoot),
+    };
+}
+/**
+ * KVState — Session-scoped persistent key-value store.
+ *
+ * Storage: <stateDir>/session_{id}.json
+ * Session ID: 8-char hex string, auto-generated if not provided.
+ *
+ * Features:
+ * - Lazy load: defers disk read until first operation.
+ * - Atomic persistence: write to temp file then rename.
+ * - Debounced auto-persist: 5-second timer after each set().
+ */
+export class KVState {
+    sessionId;
+    stateDir;
+    filePath;
+    data = null;
+    persistTimer = null;
+    loadPromise = null;
+    store;
+    constructor(sessionIdOrOptions, storageRoot) {
+        const options = resolveKVStateOptions(sessionIdOrOptions, storageRoot);
+        this.sessionId = options.sessionId ?? KVState.generateId();
+        this.stateDir = options.stateDir;
+        this.filePath = join(this.stateDir, `session_${this.sessionId}.json`);
+        this.store = new JsonFileStore(this.filePath);
+    }
+    async get(keys) {
+        await this.ensureLoaded();
+        const result = {};
+        for (const key of keys) {
+            if (Object.prototype.hasOwnProperty.call(this.data, key)) {
+                result[key] = this.data[key];
+            }
+        }
+        return result;
+    }
+    async set(values) {
+        await this.ensureLoaded();
+        for (const [key, value] of Object.entries(values)) {
+            if (RESERVED_KEYS.has(key)) {
+                logger.debug('KVState: ignoring reserved key', { key });
+                continue;
+            }
+            this.data[key] = value;
+        }
+        this.schedulePersist();
+    }
+    async list(prefix) {
+        await this.ensureLoaded();
+        if (!prefix) {
+            return { ...this.data };
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(this.data)) {
+            if (key.startsWith(prefix)) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    async clear(keys) {
+        await this.ensureLoaded();
+        let changed = false;
+        for (const key of keys) {
+            if (RESERVED_KEYS.has(key))
+                continue;
+            if (Object.prototype.hasOwnProperty.call(this.data, key)) {
+                delete this.data[key];
+                changed = true;
+            }
+        }
+        if (changed)
+            this.schedulePersist();
+    }
+    async load() {
+        const loaded = await this.store.load();
+        if (loaded) {
+            this.data = loaded;
+            if (!this.data.id)
+                this.data.id = this.sessionId;
+            if (!this.data.started_at)
+                this.data.started_at = new Date().toISOString();
+            return;
+        }
+        this.data = {
+            id: this.sessionId,
+            started_at: new Date().toISOString(),
+        };
+    }
+    async persist() {
+        if (this.data === null)
+            return;
+        await this.store.save(this.data);
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    static listSessions(optionsOrStorageRoot) {
+        const stateDir = typeof optionsOrStorageRoot === 'object' && optionsOrStorageRoot !== null
+            ? resolveKVStateOptions(optionsOrStorageRoot).stateDir
+            : resolveLegacyStateDir(optionsOrStorageRoot);
+        if (!existsSync(stateDir))
+            return [];
+        try {
+            return readdirSync(stateDir)
+                .filter(f => /^session_[0-9a-f]{8}\.json$/.test(f))
+                .map(f => f.replace(/^session_/, '').replace(/\.json$/, ''))
+                .sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    static cleanupOldSessions(keepCount, optionsOrStorageRoot) {
+        const stateDir = typeof optionsOrStorageRoot === 'object' && optionsOrStorageRoot !== null
+            ? resolveKVStateOptions(optionsOrStorageRoot).stateDir
+            : resolveLegacyStateDir(optionsOrStorageRoot);
+        if (!existsSync(stateDir))
+            return;
+        try {
+            const files = readdirSync(stateDir)
+                .filter(f => /^session_[0-9a-f]{8}\.json$/.test(f))
+                .map(f => ({
+                name: f,
+                path: join(stateDir, f),
+                mtime: (() => {
+                    try {
+                        return statSync(join(stateDir, f)).mtimeMs;
+                    }
+                    catch {
+                        return 0;
+                    }
+                })(),
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            const toDelete = files.slice(keepCount);
+            for (const f of toDelete) {
+                try {
+                    unlinkSync(f.path);
+                    logger.debug('KVState: cleaned up old session', { file: f.name });
+                }
+                catch (err) {
+                    logger.debug('KVState: could not delete session file', { file: f.name, error: summarizeError(err) });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug('KVState: cleanupOldSessions failed (non-fatal)', { error: summarizeError(err) });
+        }
+    }
+    async dispose() {
+        if (this.persistTimer !== null) {
+            clearTimeout(this.persistTimer);
+            this.persistTimer = null;
+        }
+        await this.persist();
+    }
+    async ensureLoaded() {
+        if (this.data !== null)
+            return;
+        if (!this.loadPromise) {
+            this.loadPromise = this.load().then(() => {
+                this.loadPromise = null;
+            });
+        }
+        return this.loadPromise;
+    }
+    schedulePersist() {
+        if (this.persistTimer !== null) {
+            clearTimeout(this.persistTimer);
+        }
+        this.persistTimer = setTimeout(() => {
+            this.persistTimer = null;
+            this.persist().catch(err => {
+                logger.debug('KVState: scheduled persist failed', { error: summarizeError(err) });
+            });
+        }, 5000);
+    }
+    static generateId() {
+        const bytes = new Uint8Array(4);
+        const rand = randomBytes(4);
+        bytes.set(rand);
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+}

package/dist/_internal/platform/state/mode-manager.d.ts

@@ -0,0 +1,61 @@
+import type { DomainVerbosity } from '../runtime/notifications/types.js';
+export type ModePreset = 'default' | 'vibecoding' | 'justvibes' | (string & Record<never, never>);
+export interface VerbosityDefaults {
+    write: string;
+    edit: string;
+    read: string;
+    grep: string;
+    glob: string;
+    exec: string;
+}
+export interface ModeDefinition {
+    name: ModePreset;
+    description: string;
+    verbosityDefaults: Partial<VerbosityDefaults>;
+    enforcement: 'strict' | 'advisory';
+}
+export type HITLMode = 'quiet' | 'balanced' | 'operator';
+export interface HITLModeDefinition {
+    name: HITLMode;
+    description: string;
+    defaultDomainVerbosity: DomainVerbosity;
+    quietWhileTyping: boolean;
+    batchWindowMs: number;
+}
+export declare const HITL_QUIET: HITLModeDefinition;
+export declare const HITL_BALANCED: HITLModeDefinition;
+export declare const HITL_OPERATOR: HITLModeDefinition;
+export declare class ModeManager {
+    private currentMode;
+    private modes;
+    private hitlMode;
+    private domainOverrides;
+    getMode(): ModePreset;
+    getModeDefinition(): ModeDefinition;
+    setMode(mode: ModePreset): void;
+    listModes(): ModeDefinition[];
+    registerMode(def: ModeDefinition): void;
+    getVerbosityDefaults(): Partial<VerbosityDefaults>;
+    getHITLMode(): HITLMode;
+    getHITLPreset(): HITLModeDefinition;
+    /**
+     * Switch the active HITL mode.
+     *
+     * Switching modes clears all per-domain verbosity overrides that may have
+     * been set via {@link setDomainVerbosity}. This ensures the new mode's
+     * `defaultDomainVerbosity` applies uniformly until the caller re-establishes
+     * any domain-specific overrides.
+     */
+    setHITLMode(mode: HITLMode): void;
+    listHITLPresets(): HITLModeDefinition[];
+    setDomainVerbosity(domain: string, verbosity: DomainVerbosity): void;
+    getDomainVerbosity(domain: string): DomainVerbosity;
+    getDomainOverrides(): Record<string, DomainVerbosity>;
+    applyToRouter(router: {
+        setQuietWhileTyping(enabled: boolean): void;
+        setBatchWindowMs?(ms: number): void;
+        setDefaultDomainVerbosity?(verbosity: DomainVerbosity): void;
+        setDomainVerbosity(domain: string, verbosity: DomainVerbosity): void;
+    }): void;
+}
+//# sourceMappingURL=mode-manager.d.ts.map

package/dist/_internal/platform/state/mode-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mode-manager.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/mode-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AAMzE,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAElG,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC9C,WAAW,EAAE,QAAQ,GAAG,UAAU,CAAC;CACpC;AA6CD,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,sBAAsB,EAAE,eAAe,CAAC;IACxC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,eAAO,MAAM,UAAU,EAAE,kBAMxB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,kBAM3B,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,kBAM3B,CAAC;AAQF,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAyB;IAC5C,OAAO,CAAC,KAAK,CAAyC;IAEtD,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,eAAe,CAA2C;IAMlE,OAAO,IAAI,UAAU;IAIrB,iBAAiB,IAAI,cAAc;IAInC,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAS/B,SAAS,IAAI,cAAc,EAAE;IAI7B,YAAY,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IASvC,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAQlD,WAAW,IAAI,QAAQ;IAIvB,aAAa,IAAI,kBAAkB;IAInC;;;;;;;OAOG;IACH,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAUjC,eAAe,IAAI,kBAAkB,EAAE;IAIvC,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,IAAI;IAIpE,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IAInD,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IAIrD,aAAa,CAAC,MAAM,EAAE;QACpB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QAC5C,gBAAgB,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;QACpC,yBAAyB,CAAC,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;QAC7D,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;KACtE,GAAG,IAAI;CAST"}

package/dist/_internal/platform/state/mode-manager.js

@@ -0,0 +1,146 @@
+const DEFAULT_VERBOSITY = {
+    write: 'standard',
+    edit: 'with_diff',
+    read: 'standard',
+    grep: 'matches',
+    glob: 'paths_only',
+    exec: 'standard',
+};
+const VIBECODING_VERBOSITY = {
+    write: 'count_only',
+    edit: 'minimal',
+    read: 'standard',
+    grep: 'files_only',
+    glob: 'paths_only',
+    exec: 'minimal',
+};
+const BUILT_IN_MODES = [
+    {
+        name: 'default',
+        description: 'Standard precision tool verbosity with confirmation prompts.',
+        verbosityDefaults: DEFAULT_VERBOSITY,
+        enforcement: 'advisory',
+    },
+    {
+        name: 'vibecoding',
+        description: 'Reduced verbosity for rapid iteration; still confirms destructive operations.',
+        verbosityDefaults: VIBECODING_VERBOSITY,
+        enforcement: 'advisory',
+    },
+    {
+        name: 'justvibes',
+        description: 'Minimal output, no confirmation prompts. Fast and autonomous.',
+        verbosityDefaults: VIBECODING_VERBOSITY,
+        enforcement: 'advisory',
+    },
+];
+export const HITL_QUIET = {
+    name: 'quiet',
+    description: 'Minimal verbosity. Suppresses most notifications. Batches updates in 5s windows.',
+    defaultDomainVerbosity: 'minimal',
+    quietWhileTyping: true,
+    batchWindowMs: 5_000,
+};
+export const HITL_BALANCED = {
+    name: 'balanced',
+    description: 'Normal verbosity. Standard notification flow. Batches updates in 2s windows.',
+    defaultDomainVerbosity: 'normal',
+    quietWhileTyping: true,
+    batchWindowMs: 2_000,
+};
+export const HITL_OPERATOR = {
+    name: 'operator',
+    description: 'Verbose. All notifications shown immediately. No quiet-while-typing suppression.',
+    defaultDomainVerbosity: 'verbose',
+    quietWhileTyping: false,
+    batchWindowMs: 500,
+};
+const HITL_PRESETS = [HITL_QUIET, HITL_BALANCED, HITL_OPERATOR];
+// ---------------------------------------------------------------------------
+// ModeManager
+// ---------------------------------------------------------------------------
+export class ModeManager {
+    currentMode = 'default';
+    modes = [...BUILT_IN_MODES];
+    hitlMode = 'balanced';
+    domainOverrides = new Map();
+    // -------------------------------------------------------------------------
+    // Precision tool verbosity mode API
+    // -------------------------------------------------------------------------
+    getMode() {
+        return this.currentMode;
+    }
+    getModeDefinition() {
+        return this.modes.find((m) => m.name === this.currentMode) ?? this.modes[0];
+    }
+    setMode(mode) {
+        const found = this.modes.find((m) => m.name === mode);
+        if (!found) {
+            const available = this.modes.map((m) => `"${m.name}"`).join(', ');
+            throw new Error(`Unknown mode: "${mode}". Available modes: ${available}`);
+        }
+        this.currentMode = mode;
+    }
+    listModes() {
+        return [...this.modes];
+    }
+    registerMode(def) {
+        const idx = this.modes.findIndex((m) => m.name === def.name);
+        if (idx >= 0) {
+            this.modes[idx] = def;
+        }
+        else {
+            this.modes.push(def);
+        }
+    }
+    getVerbosityDefaults() {
+        return { ...this.getModeDefinition().verbosityDefaults };
+    }
+    // -------------------------------------------------------------------------
+    // HITL UX mode API.
+    // -------------------------------------------------------------------------
+    getHITLMode() {
+        return this.hitlMode;
+    }
+    getHITLPreset() {
+        return HITL_PRESETS.find((p) => p.name === this.hitlMode) ?? HITL_BALANCED;
+    }
+    /**
+     * Switch the active HITL mode.
+     *
+     * Switching modes clears all per-domain verbosity overrides that may have
+     * been set via {@link setDomainVerbosity}. This ensures the new mode's
+     * `defaultDomainVerbosity` applies uniformly until the caller re-establishes
+     * any domain-specific overrides.
+     */
+    setHITLMode(mode) {
+        const found = HITL_PRESETS.find((p) => p.name === mode);
+        if (!found) {
+            const available = HITL_PRESETS.map((p) => `"${p.name}"`).join(', ');
+            throw new Error(`Unknown HITL mode: "${mode}". Available: ${available}`);
+        }
+        this.hitlMode = mode;
+        this.domainOverrides.clear();
+    }
+    listHITLPresets() {
+        return [...HITL_PRESETS];
+    }
+    setDomainVerbosity(domain, verbosity) {
+        this.domainOverrides.set(domain, verbosity);
+    }
+    getDomainVerbosity(domain) {
+        return this.domainOverrides.get(domain) ?? this.getHITLPreset().defaultDomainVerbosity;
+    }
+    getDomainOverrides() {
+        return Object.fromEntries(this.domainOverrides);
+    }
+    applyToRouter(router) {
+        const preset = this.getHITLPreset();
+        router.setQuietWhileTyping(preset.quietWhileTyping);
+        router.setBatchWindowMs?.(preset.batchWindowMs);
+        router.setDefaultDomainVerbosity?.(preset.defaultDomainVerbosity);
+        for (const [domain, verbosity] of this.domainOverrides) {
+            router.setDomainVerbosity(domain, verbosity);
+        }
+    }
+}

package/dist/_internal/platform/state/persistent-store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * PersistentStore — generic JSON file persistence with atomic writes.
+ *
+ * Handles lazy loading, atomic writes via a temporary file, and ensures the
+ * directory hierarchy exists. Errors are logged but not re‑thrown so that the
+ * caller can decide how to recover.
+ */
+export declare class PersistentStore<T extends Record<string, unknown>> {
+    private readonly filePath;
+    private readonly dir;
+    constructor(filePath: string);
+    /** Load JSON data from disk, or return null if the file does not exist or is invalid. */
+    load(): Promise<T | null>;
+    /** Atomically persist data to disk. */
+    persist(data: T): Promise<void>;
+}
+//# sourceMappingURL=persistent-store.d.ts.map

package/dist/_internal/platform/state/persistent-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent-store.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/persistent-store.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,QAAQ,EAAE,MAAM;IAK5B,yFAAyF;IACnF,IAAI,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAa/B,uCAAuC;IACjC,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAYtC"}

package/dist/_internal/platform/state/persistent-store.js

@@ -0,0 +1,47 @@
+import { promises as fs, renameSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+/**
+ * PersistentStore — generic JSON file persistence with atomic writes.
+ *
+ * Handles lazy loading, atomic writes via a temporary file, and ensures the
+ * directory hierarchy exists. Errors are logged but not re‑thrown so that the
+ * caller can decide how to recover.
+ */
+export class PersistentStore {
+    filePath;
+    dir;
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.dir = join(filePath, '..');
+    }
+    /** Load JSON data from disk, or return null if the file does not exist or is invalid. */
+    async load() {
+        if (!existsSync(this.filePath)) {
+            return null;
+        }
+        try {
+            const raw = await fs.readFile(this.filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            logger.debug('PersistentStore: failed to load, starting fresh', { file: this.filePath, error: summarizeError(err) });
+            return null;
+        }
+    }
+    /** Atomically persist data to disk. */
+    async persist(data) {
+        try {
+            await fs.mkdir(this.dir, { recursive: true });
+            const tmpPath = `${this.filePath}.tmp`;
+            const content = JSON.stringify(data, null, 2) + '\n';
+            await fs.writeFile(tmpPath, content, 'utf-8');
+            // renameSync is atomic on POSIX
+            await fs.rename(tmpPath, this.filePath);
+        }
+        catch (err) {
+            logger.debug('PersistentStore: persist failed (non-fatal)', { file: this.filePath, error: summarizeError(err) });
+        }
+    }
+}

package/dist/_internal/platform/state/project-index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A file entry in the flat in-memory index.
+ */
+export interface FileEntry {
+    /** Path relative to project root, using forward slashes. */
+    path: string;
+    /** Estimated LLM token count. */
+    tokens: number;
+}
+/**
+ * ProjectIndex — In-memory project file index with token counts.
+ *
+ * Singleton per process. Loaded at startup from disk in the background.
+ * Mutations are debounced: flush happens 5 seconds after last write.
+ *
+ * Disk format: v4 tree (see DiskFormat above).
+ */
+export declare class ProjectIndex {
+    private readonly indexPath;
+    private readonly projectRoot;
+    readonly baseDir: string;
+    private files;
+    private flushTimer;
+    private createdAt;
+    private loaded;
+    constructor(baseDir: string);
+    /**
+     * Load the index from disk.
+     * Non-blocking: called at startup, safe to call multiple times.
+     */
+    load(): Promise<void>;
+    /**
+     * Flush to disk immediately, bypassing debounce.
+     */
+    forceFlush(): Promise<void>;
+    getFiles(): FileEntry[];
+    getFile(path: string): FileEntry | null;
+    getFilesByPrefix(prefix: string): FileEntry[];
+    /** Return count of files by extension (e.g. { ts: 42, json: 5 }). */
+    getTypeCounts(): Record<string, number>;
+    getTotalTokens(): number;
+    /**
+     * Insert or update a file entry.
+     * If tokens is not provided, attempts to estimate from disk.
+     */
+    upsertFile(path: string, tokens?: number): void;
+    /**
+     * Touch an existing file entry (update token count from disk if possible).
+     * No-op if file not in index.
+     */
+    touchFile(path: string): void;
+    removeFile(path: string): void;
+    private normalizePath;
+    dispose(): Promise<void>;
+    private scheduleFlush;
+    private flush;
+}
+//# sourceMappingURL=project-index.d.ts.map

package/dist/_internal/platform/state/project-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-index.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/state/project-index.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAyBD;;;;;;;GAOG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,MAAM,CAAS;gBAEX,OAAO,EAAE,MAAM;IAU3B;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC,QAAQ,IAAI,SAAS,EAAE;IAIvB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAOvC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE;IAW7C,qEAAqE;IACrE,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAUvC,cAAc,IAAI,MAAM;IAUxB;;;OAGG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/C;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAc7B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAW9B,OAAO,CAAC,aAAa;IAWf,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B,OAAO,CAAC,aAAa;YAUP,KAAK;CAiCpB"}