@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/shared/schema-fingerprint.js

@@ -0,0 +1,163 @@
+/**
+ * Output schema fingerprint utility.
+ *
+ * Provides stable SHA-256 fingerprints derived from the sorted key set of a
+ * tool result object. The same output mode / input class always produces the
+ * same fingerprint because the hash is computed from the sorted key names, not
+ * from the values — making it a schema-level identity rather than a content hash.
+ *
+ * Integration pattern:
+ *   1. After a mode-specific result is produced, call `appendSchemaFingerprint`.
+ *   2. The `_meta.outputSchemaFingerprint` field is appended to the result object.
+ *   3. When the feature flag is disabled the result object is returned unchanged.
+ */
+/**
+ * Checks the runtime feature flags explicitly supplied by the composition root.
+ */
+export function isSchemaFingerprintEnabled(options = {}) {
+    return options.featureFlags?.isEnabled('output-schema-fingerprint') ?? false;
+}
+// ── Core fingerprinting ───────────────────────────────────────────────────────
+/**
+ * Canonical schema shape IDs per tool and output mode.
+ *
+ * The shape ID is the stable, human-readable identifier for what the schema
+ * looks like before the hash is computed. It encodes the tool name and mode
+ * so that diagnostics can group / filter by shape without needing to know the
+ * full fingerprint.
+ */
+export const SCHEMA_SHAPE_IDS = {
+    // find tool modes
+    'find:files': 'find.files.v1',
+    'find:content': 'find.content.v1',
+    'find:symbols': 'find.symbols.v1',
+    'find:references': 'find.references.v1',
+    'find:structural': 'find.structural.v1',
+    'find:multi': 'find.multi.v1',
+    // analyze tool modes
+    'analyze:impact': 'analyze.impact.v1',
+    'analyze:dependencies': 'analyze.dependencies.v1',
+    'analyze:dead_code': 'analyze.dead_code.v1',
+    'analyze:security': 'analyze.security.v1',
+    'analyze:coverage': 'analyze.coverage.v1',
+    'analyze:bundle': 'analyze.bundle.v1',
+    'analyze:preview': 'analyze.preview.v1',
+    'analyze:diff': 'analyze.diff.v1',
+    'analyze:surface': 'analyze.surface.v1',
+    'analyze:breaking': 'analyze.breaking.v1',
+    'analyze:semantic_diff': 'analyze.semantic_diff.v1',
+    'analyze:upgrade': 'analyze.upgrade.v1',
+    'analyze:permissions': 'analyze.permissions.v1',
+    'analyze:env_audit': 'analyze.env_audit.v1',
+    'analyze:test_find': 'analyze.test_find.v1',
+    // inspect tool modes
+    'inspect:project': 'inspect.project.v1',
+    'inspect:api': 'inspect.api.v1',
+    'inspect:database': 'inspect.database.v1',
+    'inspect:components': 'inspect.components.v1',
+    'inspect:layout': 'inspect.layout.v1',
+    'inspect:accessibility': 'inspect.accessibility.v1',
+    'inspect:api_spec': 'inspect.api_spec.v1',
+    'inspect:api_validate': 'inspect.api_validate.v1',
+    'inspect:api_sync': 'inspect.api_sync.v1',
+    'inspect:scaffold': 'inspect.scaffold.v1',
+    'inspect:component_state': 'inspect.component_state.v1',
+    'inspect:render_triggers': 'inspect.render_triggers.v1',
+    'inspect:hooks': 'inspect.hooks.v1',
+    'inspect:overflow': 'inspect.overflow.v1',
+    'inspect:sizing': 'inspect.sizing.v1',
+    'inspect:stacking': 'inspect.stacking.v1',
+    'inspect:responsive': 'inspect.responsive.v1',
+    'inspect:events': 'inspect.events.v1',
+    'inspect:tailwind': 'inspect.tailwind.v1',
+    'inspect:client_boundary': 'inspect.client_boundary.v1',
+    'inspect:error_boundary': 'inspect.error_boundary.v1',
+};
+/**
+ * Returns the canonical shape ID for a given tool and mode combination.
+ * Falls back to `<tool>.<mode>.v1` for unknown combinations.
+ */
+export function getSchemaShapeId(tool, mode) {
+    const key = `${tool}:${mode}`;
+    return SCHEMA_SHAPE_IDS[key] ?? `${tool}.${mode}.v1`;
+}
+/**
+ * Compute a stable SHA-256 fingerprint from the sorted top-level key names of
+ * a result object.
+ *
+ * The hash input is the JSON-serialised sorted key array, e.g.:
+ *   `["count","files"]` → sha256 → hex string
+ *
+ * Because the hash is over keys only (not values), the same schema shape
+ * always produces the same fingerprint regardless of runtime content.
+ *
+ * Uses the Web Crypto API (available in Bun via globalThis.crypto).
+ */
+export async function computeSchemaFingerprint(result) {
+    const sortedKeys = Object.keys(result).sort();
+    const canonical = JSON.stringify(sortedKeys);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(canonical);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Synchronous variant using the synchronous `crypto.subtle.digestSync` API
+ * available in Bun. Falls back to a deterministic key-sort string when the
+ * sync API is not available (e.g. in Node.js test environments without
+ * polyfilling).
+ *
+ * This is the preferred variant for tool `execute()` paths where async is
+ * already available, but a sync escape hatch is provided for contexts where
+ * adding `await` is impractical.
+ */
+export function computeSchemaFingerprintSync(result) {
+    const sortedKeys = Object.keys(result).sort();
+    const canonical = JSON.stringify(sortedKeys);
+    // Bun exposes crypto.subtle.digestSync (non-standard, Bun-only)
+    const bunCrypto = crypto;
+    if (typeof bunCrypto.subtle?.digestSync === 'function') {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(canonical);
+        const hashBuffer = bunCrypto.subtle.digestSync('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    // Fallback: deterministic but non-cryptographic (test/non-Bun environments)
+    // Produces a stable string for the same key set.
+    let h = 0x811c9dc5;
+    for (let i = 0; i < canonical.length; i++) {
+        h ^= canonical.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
+}
+/**
+ * Append `_meta.outputSchemaFingerprint` to a result object when the feature
+ * flag is enabled. Returns the original object unchanged when the flag is
+ * disabled.
+ *
+ * @param result   The mode result object (plain, not yet JSON-stringified).
+ * @param tool     Tool name: `'find'`, `'analyze'`, or `'inspect'`.
+ * @param mode     The active output mode string (e.g. `'files'`, `'impact'`).
+ * @returns        The augmented (or original) result object.
+ */
+export function appendSchemaFingerprint(result, tool, mode, options = {}) {
+    if (!isSchemaFingerprintEnabled(options)) {
+        return result;
+    }
+    const shapeId = getSchemaShapeId(tool, mode);
+    const fingerprint = computeSchemaFingerprintSync(result);
+    const existingMeta = typeof result._meta === 'object' && result._meta !== null
+        ? result._meta
+        : undefined;
+    return {
+        ...result,
+        _meta: {
+            ...(existingMeta ?? {}),
+            schemaShapeId: shapeId,
+            outputSchemaFingerprint: fingerprint,
+        },
+    };
+}

package/dist/platform/tools/shared/validators.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared validator infrastructure for write and edit tools.
+ * Runs typecheck / lint / test / build and returns structured results.
+ */
+export type ValidatorName = 'typecheck' | 'lint' | 'test' | 'build';
+export interface ValidatorResult {
+    validator: ValidatorName;
+    passed: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+/**
+ * Run a single validator via Bun.spawn. Times out after 30 seconds.
+ */
+export declare function runValidator(name: ValidatorName, cwd: string): Promise<ValidatorResult>;
+/**
+ * Run all validators in sequence. Returns array of all failures (or empty array if all pass).
+ */
+export declare function runValidators(validators: ValidatorName[], cwd: string): Promise<ValidatorResult[]>;
+/** Format a validator failure into a human-readable message. */
+export declare function formatValidatorFailure(result: ValidatorResult): string;
+//# sourceMappingURL=validators.d.ts.map

package/dist/platform/tools/shared/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/shared/validators.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAUpE,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,aAAa,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAyC7F;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,aAAa,EAAE,EAC3B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,eAAe,EAAE,CAAC,CAO5B;AAED,gEAAgE;AAChE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAKtE"}

package/dist/platform/tools/shared/validators.js

@@ -0,0 +1,71 @@
+/**
+ * Shared validator infrastructure for write and edit tools.
+ * Runs typecheck / lint / test / build and returns structured results.
+ */
+/** Map validator name to shell command. */
+const VALIDATOR_COMMANDS = {
+    typecheck: ['npx', 'tsc', '--noEmit'],
+    lint: ['npx', 'eslint', '--no-error-on-unmatched-pattern'],
+    test: ['bun', 'test'],
+    build: ['bun', 'run', 'build'],
+};
+/**
+ * Run a single validator via Bun.spawn. Times out after 30 seconds.
+ */
+export async function runValidator(name, cwd) {
+    const cmd = VALIDATOR_COMMANDS[name];
+    const TIMEOUT_MS = 30_000;
+    const proc = Bun.spawn(cmd, {
+        cwd,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+    let timedOut = false;
+    const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        proc.kill();
+    }, TIMEOUT_MS);
+    const [exitCode, stdoutBuf, stderrBuf] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+    ]);
+    clearTimeout(timeoutHandle);
+    if (timedOut) {
+        return {
+            validator: name,
+            passed: false,
+            stdout: '',
+            stderr: `Validator '${name}' timed out after ${TIMEOUT_MS}ms`,
+            exitCode: -1,
+        };
+    }
+    return {
+        validator: name,
+        passed: exitCode === 0,
+        stdout: stdoutBuf,
+        stderr: stderrBuf,
+        exitCode,
+    };
+}
+/**
+ * Run all validators in sequence. Returns array of all failures (or empty array if all pass).
+ */
+export async function runValidators(validators, cwd) {
+    const failures = [];
+    for (const name of validators) {
+        const result = await runValidator(name, cwd);
+        if (!result.passed)
+            failures.push(result);
+    }
+    return failures;
+}
+/** Format a validator failure into a human-readable message. */
+export function formatValidatorFailure(result) {
+    const parts = [`Validator '${result.validator}' failed (exit ${result.exitCode}):`];
+    if (result.stderr.trim())
+        parts.push(result.stderr.trim());
+    if (result.stdout.trim())
+        parts.push(result.stdout.trim());
+    return parts.join('\n');
+}

package/dist/platform/tools/state/schema.d.ts

@@ -0,0 +1,197 @@
+/**
+ * JSON Schema and TypeScript types for the `state` tool.
+ */
+export declare const STATE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["get", "set", "list", "clear", "budget", "context", "memory", "telemetry", "hooks", "mode", "analytics"];
+            readonly description: string;
+        };
+        readonly keys: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "(mode: get) Keys to retrieve from KVState.";
+        };
+        readonly values: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly description: "(mode: set) Key-value pairs to write into KVState.";
+        };
+        readonly prefix: {
+            readonly type: "string";
+            readonly description: "(mode: list) Optional prefix filter. Returns only keys starting with this string.";
+        };
+        readonly view: {
+            readonly type: "string";
+            readonly enum: readonly ["summary", "full"];
+            readonly description: "(modes: list, memory, hooks, mode, analytics) Output detail level. Default: summary for inventory/reporting surfaces.";
+        };
+        readonly clearKeys: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "(mode: clear) Keys to remove from KVState.";
+        };
+        readonly memoryAction: {
+            readonly type: "string";
+            readonly enum: readonly ["get", "set", "list"];
+            readonly description: "(mode: memory) Sub-action: get reads a key, set writes a key, list shows all keys.";
+        };
+        readonly memoryKey: {
+            readonly type: "string";
+            readonly description: "(mode: memory, action: get/set) The memory file key (filename without .json extension).";
+        };
+        readonly memoryValue: {
+            readonly type: "string";
+            readonly description: "(mode: memory, action: set) JSON string or plain text to write.";
+        };
+        readonly hookAction: {
+            readonly type: "string";
+            readonly enum: readonly ["list", "enable", "disable", "add", "remove"];
+            readonly description: "(mode: hooks) Sub-action: list all hooks; enable/disable by name; add a new hook; remove by name.";
+        };
+        readonly hookName: {
+            readonly type: "string";
+            readonly description: "(mode: hooks, action: enable/disable/remove) Name of the hook to target.";
+        };
+        readonly hookDefinition: {
+            readonly type: "object";
+            readonly description: "(mode: hooks, action: add) Hook definition object with eventPattern and hook fields.";
+            readonly properties: {
+                readonly eventPattern: {
+                    readonly type: "string";
+                    readonly description: "Event path pattern (e.g. Pre:tool:*)";
+                };
+                readonly name: {
+                    readonly type: "string";
+                    readonly description: "Unique name for the hook.";
+                };
+                readonly type: {
+                    readonly type: "string";
+                    readonly enum: readonly ["command", "http", "ts"];
+                    readonly description: "Hook type.";
+                };
+                readonly match: {
+                    readonly type: "string";
+                    readonly description: "Event path to match.";
+                };
+                readonly command: {
+                    readonly type: "string";
+                    readonly description: "(type: command) Shell command to run.";
+                };
+                readonly url: {
+                    readonly type: "string";
+                    readonly description: "(type: http) URL to POST to.";
+                };
+                readonly path: {
+                    readonly type: "string";
+                    readonly description: "(type: ts) Path to TypeScript file.";
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly description: "Human-readable description.";
+                };
+            };
+            readonly additionalProperties: true;
+        };
+        readonly modeAction: {
+            readonly type: "string";
+            readonly enum: readonly ["get", "set", "list"];
+            readonly description: "(mode: mode) Sub-action: get returns current mode; set switches to a named mode; list returns all modes.";
+        };
+        readonly modeName: {
+            readonly type: "string";
+            readonly description: "(mode: mode, action: set) Name of the mode to switch to (e.g. default, vibecoding, justvibes).";
+        };
+        readonly analyticsAction: {
+            readonly type: "string";
+            readonly enum: readonly ["record", "query", "summary", "export", "dashboard", "sync"];
+            readonly description: "(mode: analytics) Sub-action: record a tool call; query by filter; summary aggregation; export as JSON/CSV; dashboard top-level view; sync/persist to disk.";
+        };
+        readonly analyticsTool: {
+            readonly type: "string";
+            readonly description: "(mode: analytics, action: record/query) Tool name to record or filter by.";
+        };
+        readonly analyticsArgs: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly description: "(mode: analytics, action: record) Tool args to record.";
+        };
+        readonly analyticsResult: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly description: "(mode: analytics, action: record) Tool result to record.";
+        };
+        readonly analyticsDuration: {
+            readonly type: "number";
+            readonly description: "(mode: analytics, action: record) Duration in milliseconds.";
+        };
+        readonly analyticsTokens: {
+            readonly type: "number";
+            readonly description: "(mode: analytics, action: record) Token count.";
+        };
+        readonly analyticsFilter: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly description: "(mode: analytics, action: query) Filter object: { tool?, status?, since?, until?, limit? }";
+        };
+        readonly analyticsFormat: {
+            readonly type: "string";
+            readonly enum: readonly ["json", "csv"];
+            readonly description: "(mode: analytics, action: export) Export format.";
+        };
+    };
+    readonly required: readonly ["mode"];
+    readonly additionalProperties: false;
+};
+/** All valid operation modes for the state tool. */
+export type StateMode = 'get' | 'set' | 'list' | 'clear' | 'budget' | 'context' | 'memory' | 'telemetry' | 'hooks' | 'mode' | 'analytics';
+/** Memory sub-action. */
+export type MemoryAction = 'get' | 'set' | 'list';
+/** Hooks sub-action. */
+export type HookAction = 'list' | 'enable' | 'disable' | 'add' | 'remove';
+/** Mode sub-action. */
+export type ModeAction = 'get' | 'set' | 'list';
+/** Analytics sub-action. */
+export type AnalyticsAction = 'record' | 'query' | 'summary' | 'export' | 'dashboard' | 'sync';
+/** Full input shape for the state tool. */
+export interface StateInput {
+    mode: StateMode;
+    keys?: string[];
+    values?: Record<string, unknown>;
+    prefix?: string;
+    view?: 'summary' | 'full';
+    clearKeys?: string[];
+    memoryAction?: MemoryAction;
+    memoryKey?: string;
+    memoryValue?: string;
+    hookAction?: HookAction;
+    hookName?: string;
+    hookDefinition?: {
+        eventPattern: string;
+        name?: string;
+        type: 'command' | 'http' | 'ts';
+        match: string;
+        command?: string;
+        url?: string;
+        path?: string;
+        description?: string;
+        [key: string]: unknown;
+    };
+    modeAction?: ModeAction;
+    modeName?: string;
+    analyticsAction?: AnalyticsAction;
+    analyticsTool?: string;
+    analyticsArgs?: Record<string, unknown>;
+    analyticsResult?: Record<string, unknown>;
+    analyticsDuration?: number;
+    analyticsTokens?: number;
+    analyticsFilter?: Record<string, unknown>;
+    analyticsFormat?: 'json' | 'csv';
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/state/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/state/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4HpB,CAAC;AAEX,oDAAoD;AACpD,MAAM,MAAM,SAAS,GACjB,KAAK,GACL,KAAK,GACL,MAAM,GACN,OAAO,GACP,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,WAAW,GACX,OAAO,GACP,MAAM,GACN,WAAW,CAAC;AAEhB,yBAAyB;AACzB,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAElD,wBAAwB;AACxB,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE1E,uBAAuB;AACvB,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAEhD,4BAA4B;AAC5B,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,CAAC;AAE/F,2CAA2C;AAC3C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,SAAS,CAAC;IAGhB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAGhB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAGjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAG1B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IAGrB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;QAChC,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;IAGF,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAGlB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAClC"}

package/dist/platform/tools/state/schema.js

@@ -0,0 +1,127 @@
+/**
+ * JSON Schema and TypeScript types for the `state` tool.
+ */
+export const STATE_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['get', 'set', 'list', 'clear', 'budget', 'context', 'memory', 'telemetry', 'hooks', 'mode', 'analytics'],
+            description: 'Operation mode: get/set/list/clear manipulate KVState; budget returns token usage;'
+                + ' context returns conversation info; memory accesses persistent .goodvibes/memory files;'
+                + ' telemetry returns session telemetry summary;'
+                + ' hooks manages registered hooks (list/enable/disable/add/remove);'
+                + ' mode manages output verbosity mode (get/set/list);'
+                + ' analytics manages TelemetryDB (record/query/summary/export/dashboard/sync).',
+        },
+        keys: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '(mode: get) Keys to retrieve from KVState.',
+        },
+        values: {
+            type: 'object',
+            additionalProperties: true,
+            description: '(mode: set) Key-value pairs to write into KVState.',
+        },
+        prefix: {
+            type: 'string',
+            description: '(mode: list) Optional prefix filter. Returns only keys starting with this string.',
+        },
+        view: {
+            type: 'string',
+            enum: ['summary', 'full'],
+            description: '(modes: list, memory, hooks, mode, analytics) Output detail level. Default: summary for inventory/reporting surfaces.',
+        },
+        clearKeys: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '(mode: clear) Keys to remove from KVState.',
+        },
+        memoryAction: {
+            type: 'string',
+            enum: ['get', 'set', 'list'],
+            description: '(mode: memory) Sub-action: get reads a key, set writes a key, list shows all keys.',
+        },
+        memoryKey: {
+            type: 'string',
+            description: '(mode: memory, action: get/set) The memory file key (filename without .json extension).',
+        },
+        memoryValue: {
+            type: 'string',
+            description: '(mode: memory, action: set) JSON string or plain text to write.',
+        },
+        hookAction: {
+            type: 'string',
+            enum: ['list', 'enable', 'disable', 'add', 'remove'],
+            description: '(mode: hooks) Sub-action: list all hooks; enable/disable by name; add a new hook; remove by name.',
+        },
+        hookName: {
+            type: 'string',
+            description: '(mode: hooks, action: enable/disable/remove) Name of the hook to target.',
+        },
+        hookDefinition: {
+            type: 'object',
+            description: '(mode: hooks, action: add) Hook definition object with eventPattern and hook fields.',
+            properties: {
+                eventPattern: { type: 'string', description: 'Event path pattern (e.g. Pre:tool:*)' },
+                name: { type: 'string', description: 'Unique name for the hook.' },
+                type: { type: 'string', enum: ['command', 'http', 'ts'], description: 'Hook type.' },
+                match: { type: 'string', description: 'Event path to match.' },
+                command: { type: 'string', description: '(type: command) Shell command to run.' },
+                url: { type: 'string', description: '(type: http) URL to POST to.' },
+                path: { type: 'string', description: '(type: ts) Path to TypeScript file.' },
+                description: { type: 'string', description: 'Human-readable description.' },
+            },
+            additionalProperties: true,
+        },
+        modeAction: {
+            type: 'string',
+            enum: ['get', 'set', 'list'],
+            description: '(mode: mode) Sub-action: get returns current mode; set switches to a named mode; list returns all modes.',
+        },
+        modeName: {
+            type: 'string',
+            description: '(mode: mode, action: set) Name of the mode to switch to (e.g. default, vibecoding, justvibes).',
+        },
+        analyticsAction: {
+            type: 'string',
+            enum: ['record', 'query', 'summary', 'export', 'dashboard', 'sync'],
+            description: '(mode: analytics) Sub-action: record a tool call; query by filter; summary aggregation; export as JSON/CSV; dashboard top-level view; sync/persist to disk.',
+        },
+        analyticsTool: {
+            type: 'string',
+            description: '(mode: analytics, action: record/query) Tool name to record or filter by.',
+        },
+        analyticsArgs: {
+            type: 'object',
+            additionalProperties: true,
+            description: '(mode: analytics, action: record) Tool args to record.',
+        },
+        analyticsResult: {
+            type: 'object',
+            additionalProperties: true,
+            description: '(mode: analytics, action: record) Tool result to record.',
+        },
+        analyticsDuration: {
+            type: 'number',
+            description: '(mode: analytics, action: record) Duration in milliseconds.',
+        },
+        analyticsTokens: {
+            type: 'number',
+            description: '(mode: analytics, action: record) Token count.',
+        },
+        analyticsFilter: {
+            type: 'object',
+            additionalProperties: true,
+            description: '(mode: analytics, action: query) Filter object: { tool?, status?, since?, until?, limit? }',
+        },
+        analyticsFormat: {
+            type: 'string',
+            enum: ['json', 'csv'],
+            description: '(mode: analytics, action: export) Export format.',
+        },
+    },
+    required: ['mode'],
+    additionalProperties: false,
+};

package/dist/platform/tools/task/index.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '../../types/tools.js';
+import type { CrossSessionTaskRegistry } from '../../sessions/orchestration/index.js';
+export declare function createTaskTool(registry: CrossSessionTaskRegistry): Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/tools/task/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/task/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAuB,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AAkB3G,wBAAgB,cAAc,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI,CAgJvE"}