@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/packages/extension-sdk/src/plugin.js

@@ -1,173 +0,0 @@
-import { toTextResponse, toErrorResponse } from './bridges/shared.js';
-export const jsonResponse = toTextResponse;
-export const errorResponse = toErrorResponse;
-export class ExtensionBuilder {
-    _id;
-    _version;
-    _name = '';
-    _description = '';
-    _author = '';
-    _sourceRepo = '';
-    _compatibleCore = '>=0.1.0';
-    _profiles = ['full'];
-    _tools = [];
-    _workflows = [];
-    _allowCommands = [];
-    _allowHosts = [];
-    _allowTools = [];
-    _metrics = [];
-    _configDefaults = {};
-    _onLoadHandler;
-    _onValidateHandler;
-    _onActivateHandler;
-    _onDeactivateHandler;
-    constructor(id, version) {
-        this._id = id;
-        this._version = version;
-    }
-    get id() {
-        return this._id;
-    }
-    get version() {
-        return this._version;
-    }
-    get pluginName() {
-        return this._name;
-    }
-    get pluginDescription() {
-        return this._description;
-    }
-    get pluginAuthor() {
-        return this._author;
-    }
-    get pluginSourceRepo() {
-        return this._sourceRepo;
-    }
-    get compatibleCoreRange() {
-        return this._compatibleCore;
-    }
-    get profiles() {
-        return this._profiles;
-    }
-    get tools() {
-        return this._tools;
-    }
-    get workflows() {
-        return this._workflows;
-    }
-    get allowedCommands() {
-        return this._allowCommands;
-    }
-    get allowedHosts() {
-        return this._allowHosts;
-    }
-    get allowedTools() {
-        return this._allowTools;
-    }
-    get declaredMetrics() {
-        return this._metrics;
-    }
-    get configDefaults() {
-        return this._configDefaults;
-    }
-    get onLoadHandler() {
-        return this._onLoadHandler;
-    }
-    get onValidateHandler() {
-        return this._onValidateHandler;
-    }
-    get onActivateHandler() {
-        return this._onActivateHandler;
-    }
-    get onDeactivateHandler() {
-        return this._onDeactivateHandler;
-    }
-    name(n) {
-        this._name = n;
-        return this;
-    }
-    description(desc) {
-        this._description = desc;
-        return this;
-    }
-    author(a) {
-        this._author = a;
-        return this;
-    }
-    sourceRepo(url) {
-        this._sourceRepo = url;
-        return this;
-    }
-    compatibleCore(range) {
-        this._compatibleCore = range;
-        return this;
-    }
-    mergeMetadata(meta) {
-        if (!this._name && meta.name)
-            this._name = meta.name;
-        if (!this._description && meta.description)
-            this._description = meta.description;
-        if (!this._author && meta.author)
-            this._author = meta.author;
-        if (!this._sourceRepo && meta.source_repo)
-            this._sourceRepo = meta.source_repo;
-        return this;
-    }
-    profile(p) {
-        this._profiles = Array.isArray(p) ? p : [p];
-        return this;
-    }
-    allowCommand(cmd) {
-        this._allowCommands.push(...(Array.isArray(cmd) ? cmd : [cmd]));
-        return this;
-    }
-    allowHost(host) {
-        this._allowHosts.push(...(Array.isArray(host) ? host : [host]));
-        return this;
-    }
-    allowTool(tool) {
-        this._allowTools.push(...(Array.isArray(tool) ? tool : [tool]));
-        return this;
-    }
-    metric(m) {
-        this._metrics.push(...(Array.isArray(m) ? m : [m]));
-        return this;
-    }
-    configDefault(key, value) {
-        this._configDefaults[key] = value;
-        return this;
-    }
-    tool(name, desc, schema, handler, profiles) {
-        this._tools.push({
-            name,
-            description: desc,
-            schema: { type: 'object', properties: schema },
-            handler,
-            profiles,
-        });
-        return this;
-    }
-    workflow(workflow) {
-        this._workflows.push(...(Array.isArray(workflow) ? workflow : [workflow]));
-        return this;
-    }
-    onLoad(h) {
-        this._onLoadHandler = h;
-        return this;
-    }
-    onValidate(h) {
-        this._onValidateHandler = h;
-        return this;
-    }
-    onActivate(h) {
-        this._onActivateHandler = h;
-        return this;
-    }
-    onDeactivate(h) {
-        this._onDeactivateHandler = h;
-        return this;
-    }
-}
-export function createExtension(id, version) {
-    return new ExtensionBuilder(id, version);
-}

package/dist/packages/extension-sdk/src/workflow.d.ts

@@ -1,171 +0,0 @@
-export interface RetryPolicy {
-    maxAttempts: number;
-    backoffMs: number;
-    multiplier?: number;
-}
-export type WorkflowNodeType = 'tool' | 'sequence' | 'parallel' | 'branch' | 'fallback';
-export interface ToolNode {
-    readonly kind: 'tool';
-    readonly id: string;
-    readonly toolName: string;
-    readonly input?: Record<string, unknown>;
-    readonly timeoutMs?: number;
-    readonly retry?: RetryPolicy;
-}
-export interface SequenceNode {
-    readonly kind: 'sequence';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-}
-export interface ParallelNode {
-    readonly kind: 'parallel';
-    readonly id: string;
-    readonly steps: WorkflowNode[];
-    readonly maxConcurrency?: number;
-    readonly failFast?: boolean;
-}
-export interface BranchNode {
-    readonly kind: 'branch';
-    readonly id: string;
-    readonly predicateId: string;
-    readonly predicateFn?: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>;
-    readonly whenTrue: WorkflowNode;
-    readonly whenFalse?: WorkflowNode;
-}
-export interface FallbackNode {
-    readonly kind: 'fallback';
-    readonly id: string;
-    readonly primary: WorkflowNode;
-    readonly fallback: WorkflowNode;
-}
-export type WorkflowNode = ToolNode | SequenceNode | ParallelNode | BranchNode | FallbackNode;
-export interface ToolNodeOptions {
-    input?: Record<string, unknown>;
-    retry?: RetryPolicy;
-    timeoutMs?: number;
-}
-export interface WorkflowExecutionContext {
-    readonly workflowRunId: string;
-    readonly profile: string;
-    invokeTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
-    emitSpan(name: string, attrs?: Record<string, unknown>): void;
-    emitMetric(name: string, value: number, type: 'counter' | 'gauge' | 'histogram', attrs?: Record<string, unknown>): void;
-    getConfig<T = unknown>(path: string, fallback?: T): T;
-}
-export interface WorkflowRouteStep {
-    readonly id: string;
-    readonly toolName: string;
-    readonly description: string;
-    readonly prerequisites: string[];
-    readonly parallel?: boolean;
-    readonly expectedInputs?: Record<string, string>;
-    readonly evidenceNodeType?: string;
-}
-export type WorkflowRouteKind = 'preset' | 'workflow';
-export interface WorkflowRouteMetadata {
-    readonly kind: WorkflowRouteKind;
-    readonly triggerPatterns: RegExp[];
-    readonly steps: WorkflowRouteStep[];
-    readonly requiredDomains: string[];
-    readonly priority: number;
-}
-export interface WorkflowContract {
-    readonly kind: 'workflow-contract';
-    readonly version: 1;
-    readonly id: string;
-    readonly displayName: string;
-    readonly description?: string;
-    readonly tags?: string[];
-    readonly timeoutMs?: number;
-    readonly defaultMaxConcurrency?: number;
-    readonly route?: WorkflowRouteMetadata;
-    build(ctx: WorkflowExecutionContext): WorkflowNode;
-    onStart?(ctx: WorkflowExecutionContext): Promise<void> | void;
-    onFinish?(ctx: WorkflowExecutionContext, result: unknown): Promise<void> | void;
-    onError?(ctx: WorkflowExecutionContext, error: Error): Promise<void> | void;
-}
-export declare abstract class WorkflowNodeBuilder<T extends WorkflowNode> {
-    protected id: string;
-    constructor(id: string);
-    abstract build(): T;
-}
-type AnyWorkflowNodeBuilder = WorkflowNodeBuilder<WorkflowNode>;
-export declare class ToolNodeBuilder extends WorkflowNodeBuilder<ToolNode> {
-    private toolName;
-    private _input?;
-    private _retry?;
-    private _timeoutMs?;
-    constructor(id: string, toolName: string);
-    input(input: Record<string, unknown>): this;
-    retry(policy: RetryPolicy): this;
-    timeout(ms: number): this;
-    build(): ToolNode;
-}
-declare abstract class CompositeNodeBuilder<T extends WorkflowNode> extends WorkflowNodeBuilder<T> {
-    protected _steps: AnyWorkflowNodeBuilder[];
-    step(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    tool(id: string, toolName: string, config?: ToolNodeOptions | ((b: ToolNodeBuilder) => void)): this;
-    sequence(id: string, config?: (b: SequenceNodeBuilder) => void): this;
-    parallel(id: string, config?: (b: ParallelNodeBuilder) => void): this;
-    branch(id: string, predicateId: string, config?: (b: BranchNodeBuilder) => void): this;
-    fallback(id: string, config?: (b: FallbackNodeBuilder) => void): this;
-}
-export declare class SequenceNodeBuilder extends CompositeNodeBuilder<SequenceNode> {
-    build(): SequenceNode;
-}
-export declare class ParallelNodeBuilder extends CompositeNodeBuilder<ParallelNode> {
-    private _maxConcurrency?;
-    private _failFast?;
-    maxConcurrency(concurrency: number): this;
-    failFast(ff: boolean): this;
-    build(): ParallelNode;
-}
-export declare class BranchNodeBuilder extends WorkflowNodeBuilder<BranchNode> {
-    private predicateId;
-    private _predicateFn?;
-    private _whenTrue?;
-    private _whenFalse?;
-    constructor(id: string, predicateId: string);
-    predicateFn(fn: (ctx: WorkflowExecutionContext) => boolean | Promise<boolean>): this;
-    whenTrue(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    whenFalse(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    build(): BranchNode;
-}
-export declare class FallbackNodeBuilder extends WorkflowNodeBuilder<FallbackNode> {
-    private _primary?;
-    private _fallback?;
-    primary(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    fallback(nodeBuilder: AnyWorkflowNodeBuilder): this;
-    build(): FallbackNode;
-}
-export declare class WorkflowBuilder {
-    private _id;
-    private _displayName;
-    private _description?;
-    private _tags?;
-    private _timeoutMs?;
-    private _defaultMaxConcurrency?;
-    private _route?;
-    private _buildFn;
-    private _onStart?;
-    private _onFinish?;
-    private _onError?;
-    constructor(id: string, displayName: string);
-    description(desc: string): this;
-    tags(tags: string[]): this;
-    timeoutMs(timeout: number): this;
-    defaultMaxConcurrency(max: number): this;
-    route(route: WorkflowRouteMetadata): this;
-    buildGraph(fn: (ctx: WorkflowExecutionContext) => AnyWorkflowNodeBuilder): this;
-    onStart(fn: (ctx: WorkflowExecutionContext) => Promise<void> | void): this;
-    onFinish(fn: (ctx: WorkflowExecutionContext, result: unknown) => Promise<void> | void): this;
-    onError(fn: (ctx: WorkflowExecutionContext, error: Error) => Promise<void> | void): this;
-    build(): WorkflowContract;
-}
-export declare function createWorkflow(id: string, displayName: string): WorkflowBuilder;
-export declare function toolNode(id: string, toolName: string): ToolNodeBuilder;
-export declare function sequenceNode(id: string): SequenceNodeBuilder;
-export declare function parallelNode(id: string): ParallelNodeBuilder;
-export declare function branchNode(id: string, predicateId: string): BranchNodeBuilder;
-export declare function fallbackNode(id: string): FallbackNodeBuilder;
-export {};

package/dist/packages/extension-sdk/src/workflow.js

@@ -1,272 +0,0 @@
-export class WorkflowNodeBuilder {
-    id;
-    constructor(id) {
-        this.id = id;
-    }
-}
-export class ToolNodeBuilder extends WorkflowNodeBuilder {
-    toolName;
-    _input;
-    _retry;
-    _timeoutMs;
-    constructor(id, toolName) {
-        super(id);
-        this.toolName = toolName;
-    }
-    input(input) {
-        this._input = input;
-        return this;
-    }
-    retry(policy) {
-        this._retry = policy;
-        return this;
-    }
-    timeout(ms) {
-        this._timeoutMs = ms;
-        return this;
-    }
-    build() {
-        return {
-            kind: 'tool',
-            id: this.id,
-            toolName: this.toolName,
-            input: this._input,
-            retry: this._retry,
-            timeoutMs: this._timeoutMs,
-        };
-    }
-}
-class CompositeNodeBuilder extends WorkflowNodeBuilder {
-    _steps = [];
-    step(nodeBuilder) {
-        this._steps.push(nodeBuilder);
-        return this;
-    }
-    tool(id, toolName, config) {
-        const builder = new ToolNodeBuilder(id, toolName);
-        if (config) {
-            if (typeof config === 'function') {
-                config(builder);
-            }
-            else {
-                if (config.input)
-                    builder.input(config.input);
-                if (config.retry)
-                    builder.retry(config.retry);
-                if (config.timeoutMs !== undefined)
-                    builder.timeout(config.timeoutMs);
-            }
-        }
-        this._steps.push(builder);
-        return this;
-    }
-    sequence(id, config) {
-        const builder = new SequenceNodeBuilder(id);
-        if (config)
-            config(builder);
-        this._steps.push(builder);
-        return this;
-    }
-    parallel(id, config) {
-        const builder = new ParallelNodeBuilder(id);
-        if (config)
-            config(builder);
-        this._steps.push(builder);
-        return this;
-    }
-    branch(id, predicateId, config) {
-        const builder = new BranchNodeBuilder(id, predicateId);
-        if (config)
-            config(builder);
-        this._steps.push(builder);
-        return this;
-    }
-    fallback(id, config) {
-        const builder = new FallbackNodeBuilder(id);
-        if (config)
-            config(builder);
-        this._steps.push(builder);
-        return this;
-    }
-}
-export class SequenceNodeBuilder extends CompositeNodeBuilder {
-    build() {
-        return {
-            kind: 'sequence',
-            id: this.id,
-            steps: this._steps.map((b) => b.build()),
-        };
-    }
-}
-export class ParallelNodeBuilder extends CompositeNodeBuilder {
-    _maxConcurrency = 4;
-    _failFast = false;
-    maxConcurrency(concurrency) {
-        this._maxConcurrency = concurrency;
-        return this;
-    }
-    failFast(ff) {
-        this._failFast = ff;
-        return this;
-    }
-    build() {
-        return {
-            kind: 'parallel',
-            id: this.id,
-            steps: this._steps.map((b) => b.build()),
-            maxConcurrency: this._maxConcurrency,
-            failFast: this._failFast,
-        };
-    }
-}
-export class BranchNodeBuilder extends WorkflowNodeBuilder {
-    predicateId;
-    _predicateFn;
-    _whenTrue;
-    _whenFalse;
-    constructor(id, predicateId) {
-        super(id);
-        this.predicateId = predicateId;
-    }
-    predicateFn(fn) {
-        this._predicateFn = fn;
-        return this;
-    }
-    whenTrue(nodeBuilder) {
-        this._whenTrue = nodeBuilder;
-        return this;
-    }
-    whenFalse(nodeBuilder) {
-        this._whenFalse = nodeBuilder;
-        return this;
-    }
-    build() {
-        if (!this._whenTrue) {
-            throw new Error(`BranchNode '${this.id}' requires a whenTrue step`);
-        }
-        return {
-            kind: 'branch',
-            id: this.id,
-            predicateId: this.predicateId,
-            predicateFn: this._predicateFn,
-            whenTrue: this._whenTrue.build(),
-            whenFalse: this._whenFalse ? this._whenFalse.build() : undefined,
-        };
-    }
-}
-export class FallbackNodeBuilder extends WorkflowNodeBuilder {
-    _primary;
-    _fallback;
-    primary(nodeBuilder) {
-        this._primary = nodeBuilder;
-        return this;
-    }
-    fallback(nodeBuilder) {
-        this._fallback = nodeBuilder;
-        return this;
-    }
-    build() {
-        if (!this._primary) {
-            throw new Error(`FallbackNode '${this.id}' requires a primary step`);
-        }
-        if (!this._fallback) {
-            throw new Error(`FallbackNode '${this.id}' requires a fallback step`);
-        }
-        return {
-            kind: 'fallback',
-            id: this.id,
-            primary: this._primary.build(),
-            fallback: this._fallback.build(),
-        };
-    }
-}
-export class WorkflowBuilder {
-    _id;
-    _displayName;
-    _description;
-    _tags;
-    _timeoutMs;
-    _defaultMaxConcurrency;
-    _route;
-    _buildFn;
-    _onStart;
-    _onFinish;
-    _onError;
-    constructor(id, displayName) {
-        this._id = id;
-        this._displayName = displayName;
-    }
-    description(desc) {
-        this._description = desc;
-        return this;
-    }
-    tags(tags) {
-        this._tags = tags;
-        return this;
-    }
-    timeoutMs(timeout) {
-        this._timeoutMs = timeout;
-        return this;
-    }
-    defaultMaxConcurrency(max) {
-        this._defaultMaxConcurrency = max;
-        return this;
-    }
-    route(route) {
-        this._route = route;
-        return this;
-    }
-    buildGraph(fn) {
-        this._buildFn = (ctx) => fn(ctx).build();
-        return this;
-    }
-    onStart(fn) {
-        this._onStart = fn;
-        return this;
-    }
-    onFinish(fn) {
-        this._onFinish = fn;
-        return this;
-    }
-    onError(fn) {
-        this._onError = fn;
-        return this;
-    }
-    build() {
-        if (!this._buildFn)
-            throw new Error(`WorkflowBuilder '${this._id}' needs a buildGraph() function.`);
-        return {
-            kind: 'workflow-contract',
-            version: 1,
-            id: this._id,
-            displayName: this._displayName,
-            description: this._description,
-            tags: this._tags,
-            timeoutMs: this._timeoutMs,
-            defaultMaxConcurrency: this._defaultMaxConcurrency,
-            route: this._route,
-            build: this._buildFn,
-            onStart: this._onStart,
-            onFinish: this._onFinish,
-            onError: this._onError,
-        };
-    }
-}
-export function createWorkflow(id, displayName) {
-    return new WorkflowBuilder(id, displayName);
-}
-export function toolNode(id, toolName) {
-    return new ToolNodeBuilder(id, toolName);
-}
-export function sequenceNode(id) {
-    return new SequenceNodeBuilder(id);
-}
-export function parallelNode(id) {
-    return new ParallelNodeBuilder(id);
-}
-export function branchNode(id, predicateId) {
-    return new BranchNodeBuilder(id, predicateId);
-}
-export function fallbackNode(id) {
-    return new FallbackNodeBuilder(id);
-}

package/dist/src/cli/doctor.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/src/cli/doctor.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import { formatEnvironmentDoctorReport, runEnvironmentDoctor } from '../utils/environmentDoctor.js';
-const report = await runEnvironmentDoctor({ includeBridgeHealth: true });
-process.stdout.write(`${formatEnvironmentDoctorReport(report)}\n`);
-process.exit(0);

package/dist/src/config/search-defaults.d.ts

@@ -1,46 +0,0 @@
-export declare const DEFAULT_QUERY_CATEGORY_PROFILE_CONFIGS: {
-    pattern: string;
-    flags: string;
-    domainBoosts: {
-        domain: string;
-        weight: number;
-    }[];
-}[];
-export declare const DEFAULT_CJK_QUERY_ALIAS_CONFIGS: {
-    pattern: string;
-    tokens: string[];
-}[];
-export declare const DEFAULT_INTENT_TOOL_BOOST_RULE_CONFIGS: {
-    pattern: string;
-    flags: string;
-    boosts: {
-        tool: string;
-        bonus: number;
-    }[];
-}[];
-export declare const DEFAULT_SEARCH_CONFIG: {
-    queryCategoryProfiles: {
-        pattern: string;
-        flags: string;
-        domainBoosts: {
-            domain: string;
-            weight: number;
-        }[];
-    }[];
-    cjkQueryAliases: {
-        pattern: string;
-        tokens: string[];
-    }[];
-    intentToolBoostRules: {
-        pattern: string;
-        flags: string;
-        boosts: {
-            tool: string;
-            bonus: number;
-        }[];
-    }[];
-    vectorEnabled: boolean;
-    vectorModelId: string;
-    vectorCosineWeight: number;
-    vectorDynamicWeight: boolean;
-};