@codebolt/codeboltjs 5.0.1 → 5.0.3

package/dist/types/autoTesting.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoTestingResponseType = exports.AutoTestingAction = void 0;
+// Actions matching backend autoTestingService.cli.ts
+var AutoTestingAction;
+(function (AutoTestingAction) {
+    // Suites
+    AutoTestingAction["SUITE_CREATE"] = "autotesting.suite.create";
+    AutoTestingAction["SUITE_GET"] = "autotesting.suite.get";
+    AutoTestingAction["SUITE_LIST"] = "autotesting.suite.list";
+    AutoTestingAction["SUITE_UPDATE"] = "autotesting.suite.update";
+    AutoTestingAction["SUITE_DELETE"] = "autotesting.suite.delete";
+    AutoTestingAction["SUITE_CASE_ADD"] = "autotesting.suite.case.add";
+    AutoTestingAction["SUITE_CASE_REMOVE"] = "autotesting.suite.case.remove";
+    // Cases
+    AutoTestingAction["CASE_CREATE"] = "autotesting.case.create";
+    AutoTestingAction["CASE_GET"] = "autotesting.case.get";
+    AutoTestingAction["CASE_LIST"] = "autotesting.case.list";
+    AutoTestingAction["CASE_UPDATE"] = "autotesting.case.update";
+    AutoTestingAction["CASE_DELETE"] = "autotesting.case.delete";
+    // Runs
+    AutoTestingAction["RUN_CREATE"] = "autotesting.run.create";
+    AutoTestingAction["RUN_GET"] = "autotesting.run.get";
+    AutoTestingAction["RUN_LIST"] = "autotesting.run.list";
+    AutoTestingAction["RUN_UPDATE_STATUS"] = "autotesting.run.update_status";
+    AutoTestingAction["RUN_CASE_UPDATE"] = "autotesting.run.case.update";
+    AutoTestingAction["RUN_STEP_UPDATE"] = "autotesting.run.step.update";
+})(AutoTestingAction || (exports.AutoTestingAction = AutoTestingAction = {}));
+// Response types matching backend responses
+var AutoTestingResponseType;
+(function (AutoTestingResponseType) {
+    AutoTestingResponseType["SUITE_CREATE_RESPONSE"] = "autotesting.suite.create.response";
+    AutoTestingResponseType["SUITE_GET_RESPONSE"] = "autotesting.suite.get.response";
+    AutoTestingResponseType["SUITE_LIST_RESPONSE"] = "autotesting.suite.list.response";
+    AutoTestingResponseType["SUITE_UPDATE_RESPONSE"] = "autotesting.suite.update.response";
+    AutoTestingResponseType["SUITE_DELETE_RESPONSE"] = "autotesting.suite.delete.response";
+    AutoTestingResponseType["SUITE_CASE_ADD_RESPONSE"] = "autotesting.suite.case.add.response";
+    AutoTestingResponseType["SUITE_CASE_REMOVE_RESPONSE"] = "autotesting.suite.case.remove.response";
+    AutoTestingResponseType["CASE_CREATE_RESPONSE"] = "autotesting.case.create.response";
+    AutoTestingResponseType["CASE_GET_RESPONSE"] = "autotesting.case.get.response";
+    AutoTestingResponseType["CASE_LIST_RESPONSE"] = "autotesting.case.list.response";
+    AutoTestingResponseType["CASE_UPDATE_RESPONSE"] = "autotesting.case.update.response";
+    AutoTestingResponseType["CASE_DELETE_RESPONSE"] = "autotesting.case.delete.response";
+    AutoTestingResponseType["RUN_CREATE_RESPONSE"] = "autotesting.run.create.response";
+    AutoTestingResponseType["RUN_GET_RESPONSE"] = "autotesting.run.get.response";
+    AutoTestingResponseType["RUN_LIST_RESPONSE"] = "autotesting.run.list.response";
+    AutoTestingResponseType["RUN_UPDATE_STATUS_RESPONSE"] = "autotesting.run.update_status.response";
+    AutoTestingResponseType["RUN_CASE_UPDATE_RESPONSE"] = "autotesting.run.case.update.response";
+    AutoTestingResponseType["RUN_STEP_UPDATE_RESPONSE"] = "autotesting.run.step.update.response";
+})(AutoTestingResponseType || (exports.AutoTestingResponseType = AutoTestingResponseType = {}));

package/dist/types/codebaseSearch.d.ts

@@ -0,0 +1,32 @@
+export interface CodeSearchResult {
+    file: string;
+    content: string;
+    language: string;
+    startLine?: number;
+    endLine?: number;
+    score?: number;
+}
+export interface CodebaseSearchOptions {
+    query: string;
+    target_directories?: string[];
+}
+export interface SearchMcpToolOptions {
+    query: string;
+    tags?: string[];
+}
+export interface CodebaseSearchResponse {
+    type?: string;
+    success: boolean;
+    message?: string;
+    results?: CodeSearchResult[];
+    timestamp?: string;
+    requestId?: string;
+}
+export interface McpToolSearchResponse {
+    type?: string;
+    success: boolean;
+    message?: string;
+    results?: any[];
+    timestamp?: string;
+    requestId?: string;
+}

package/dist/types/codebaseSearch.js

@@ -0,0 +1,3 @@
+"use strict";
+// Codebase Search Types for codeboltjs
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/codemap.d.ts

@@ -0,0 +1,83 @@
+export type CodemapStatus = 'creating' | 'done' | 'error';
+export interface CodemapSection {
+    id: string;
+    title: string;
+    description?: string;
+    files?: string[];
+    subsections?: CodemapSection[];
+}
+export interface Codemap {
+    id: string;
+    title: string;
+    description?: string;
+    query?: string;
+    sections: CodemapSection[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CodemapInfo {
+    id: string;
+    title: string;
+    description?: string;
+    query?: string;
+    status: CodemapStatus;
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateCodemapData {
+    title: string;
+    description?: string;
+    query?: string;
+}
+export interface SaveCodemapData {
+    codemap: Codemap;
+}
+export interface UpdateCodemapStatusData {
+    status: CodemapStatus;
+    error?: string;
+}
+export interface UpdateCodemapData {
+    title?: string;
+    description?: string;
+    status?: CodemapStatus;
+    error?: string;
+}
+export interface CodemapBaseResponse {
+    success: boolean;
+    code?: string;
+    message?: string;
+    error?: {
+        code: string;
+        message: string;
+        details?: any;
+    };
+}
+export interface CodemapListResponse extends CodemapBaseResponse {
+    data?: {
+        codemaps: CodemapInfo[];
+        count: number;
+    };
+}
+export interface CodemapGetResponse extends CodemapBaseResponse {
+    data?: {
+        codemap: Codemap | CodemapInfo;
+    };
+}
+export interface CodemapCreateResponse extends CodemapBaseResponse {
+    data?: {
+        codemap: CodemapInfo;
+    };
+}
+export interface CodemapSaveResponse extends CodemapBaseResponse {
+    data?: {
+        codemap: CodemapInfo;
+    };
+}
+export interface CodemapUpdateResponse extends CodemapBaseResponse {
+    data?: {
+        codemap: CodemapInfo;
+    };
+}
+export interface CodemapDeleteResponse extends CodemapBaseResponse {
+}

package/dist/types/codemap.js

@@ -0,0 +1,3 @@
+"use strict";
+// Codemap Types for codeboltjs
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/commonTypes.d.ts

@@ -159,6 +159,10 @@ export interface PendingRequest {
     messageTypes: string[];
     requestId?: string;
 }
+export interface MessageRoute {
+    messageTypes: string[];
+    handler: (message: any) => void;
+}
 export interface ServiceResponseTypeMap {
     filesystem: any;
     fsService: any;

package/dist/types/contextAssembly.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Context Assembly Types
+ * Type definitions for context assembly engine operations
+ */
+export interface ContextAssemblyBaseResponse {
+    type: string;
+    success: boolean;
+    data?: any;
+    message?: string;
+    error?: string;
+    timestamp: string;
+    requestId: string;
+}
+export interface ContextAssemblyRequest {
+    scope_variables: Record<string, any>;
+    additional_variables?: Record<string, any>;
+    input?: string;
+    explicit_memory?: string[];
+    constraints?: ContextConstraints;
+    rule_engine_ids?: string[];
+}
+export interface ContextConstraints {
+    max_tokens?: number;
+    max_sources?: number;
+    timeout_ms?: number;
+}
+export interface MemoryContribution {
+    memory_id: string;
+    memory_label: string;
+    content: string;
+    format: 'text' | 'json' | 'markdown';
+    tokens?: number;
+    source?: string;
+}
+export interface AssembledContext {
+    contributions: MemoryContribution[];
+    total_tokens: number;
+    assembly_time_ms: number;
+    applied_rules?: string[];
+    warnings?: string[];
+}
+export interface MemoryTypeSpec {
+    id: string;
+    label: string;
+    description?: string;
+    inputs_scope: string[];
+    additional_variables?: Record<string, {
+        type: string;
+        required?: boolean;
+        default?: any;
+    }>;
+    contribution: {
+        format: string;
+        max_tokens?: number;
+    };
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+    warnings?: string[];
+    resolved_memories?: string[];
+}
+export interface RuleEvaluationResult {
+    matched_rules: string[];
+    excluded_memories: string[];
+    included_memories: string[];
+    forced_memories: string[];
+}
+export interface RequiredVariablesResult {
+    scope_variables: string[];
+    additional_variables: Record<string, {
+        type: string;
+        required: boolean;
+        from_memory: string;
+    }>;
+}
+export interface ContextAssemblyResponse extends ContextAssemblyBaseResponse {
+    data?: {
+        context: AssembledContext;
+    };
+}
+export interface ContextValidateResponse extends ContextAssemblyBaseResponse {
+    data?: {
+        validation: ValidationResult;
+    };
+}
+export interface MemoryTypesResponse extends ContextAssemblyBaseResponse {
+    data?: {
+        memoryTypes: MemoryTypeSpec[];
+    };
+}
+export interface RuleEvaluationResponse extends ContextAssemblyBaseResponse {
+    data?: RuleEvaluationResult;
+}
+export interface RequiredVariablesResponse extends ContextAssemblyBaseResponse {
+    data?: RequiredVariablesResult;
+}

package/dist/types/contextAssembly.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Context Assembly Types
+ * Type definitions for context assembly engine operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/contextRuleEngine.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Context Rule Engine Types
+ * Type definitions for context rule engine operations
+ */
+export interface ContextRuleEngineBaseResponse {
+    type: string;
+    success: boolean;
+    data?: any;
+    message?: string;
+    error?: string;
+    timestamp: string;
+    requestId: string;
+}
+export type RuleOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in' | 'exists' | 'not_exists' | 'matches';
+export type RuleAction = 'include' | 'exclude' | 'force_include' | 'set_priority';
+export interface RuleCondition {
+    variable: string;
+    operator: RuleOperator;
+    value: any;
+}
+export interface Rule {
+    id?: string;
+    name: string;
+    description?: string;
+    conditions: RuleCondition[];
+    condition_logic?: 'and' | 'or';
+    action: RuleAction;
+    action_config?: {
+        memory_ids?: string[];
+        priority?: number;
+    };
+    enabled?: boolean;
+    order?: number;
+}
+export interface ContextRuleEngine {
+    id: string;
+    name: string;
+    description?: string;
+    rules: Rule[];
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PossibleVariable {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    source: 'scope' | 'memory' | 'system';
+    description?: string;
+    examples?: any[];
+}
+export interface CreateContextRuleEngineParams {
+    id?: string;
+    name: string;
+    description?: string;
+    rules: Rule[];
+    enabled?: boolean;
+}
+export interface UpdateContextRuleEngineParams {
+    name?: string;
+    description?: string;
+    rules?: Rule[];
+    enabled?: boolean;
+}
+export interface EvaluateRulesParams {
+    scope_variables: Record<string, any>;
+    additional_variables?: Record<string, any>;
+    input?: string;
+    rule_engine_ids?: string[];
+}
+export interface ContextRuleEngineResponse extends ContextRuleEngineBaseResponse {
+    data?: {
+        ruleEngine: ContextRuleEngine;
+    };
+}
+export interface ContextRuleEngineListResponse extends ContextRuleEngineBaseResponse {
+    data?: {
+        ruleEngines: ContextRuleEngine[];
+    };
+}
+export interface ContextRuleEngineDeleteResponse extends ContextRuleEngineBaseResponse {
+    data?: {
+        deleted: boolean;
+    };
+}
+export interface EvaluateRulesResponse extends ContextRuleEngineBaseResponse {
+    data?: {
+        matched_rules: string[];
+        excluded_memories: string[];
+        included_memories: string[];
+        forced_memories: string[];
+    };
+}
+export interface PossibleVariablesResponse extends ContextRuleEngineBaseResponse {
+    data?: {
+        variables: PossibleVariable[];
+    };
+}

package/dist/types/contextRuleEngine.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Context Rule Engine Types
+ * Type definitions for context rule engine operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/eventLog.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Event Log Types
+ * Type definitions for event log operations
+ */
+export interface EventLogBaseResponse {
+    type: string;
+    success: boolean;
+    data?: any;
+    message?: string;
+    error?: string;
+    timestamp: string;
+    requestId: string;
+}
+export interface EventLogInstance {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface EventLogEntry {
+    id: string;
+    instanceId: string;
+    stream_id: string;
+    event_type: string;
+    payload: Record<string, any>;
+    metadata: Record<string, any>;
+    timestamp: string;
+    sequence_number: number;
+}
+export interface EventLogDSL {
+    from: {
+        instance: string;
+        stream?: string;
+    };
+    where?: EventLogCondition[];
+    select?: string[];
+    orderBy?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+    offset?: number;
+    reduce?: {
+        type: 'count' | 'sum' | 'avg' | 'min' | 'max' | 'collect';
+        field?: string;
+        groupBy?: string[];
+    };
+}
+export interface EventLogCondition {
+    field: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'in' | 'between';
+    value: any;
+}
+export interface EventLogQueryResult {
+    events?: EventLogEntry[];
+    aggregation?: any;
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+export interface CreateEventLogInstanceParams {
+    name: string;
+    description?: string;
+}
+export interface UpdateEventLogInstanceParams {
+    name?: string;
+    description?: string;
+}
+export interface AppendEventParams {
+    instanceId: string;
+    stream_id?: string;
+    streamId?: string;
+    event_type?: string;
+    eventType?: string;
+    payload?: Record<string, any>;
+    metadata?: Record<string, any>;
+    autoCreateInstance?: boolean;
+}
+export interface AppendEventsParams {
+    instanceId: string;
+    events: Array<{
+        stream_id?: string;
+        streamId?: string;
+        event_type?: string;
+        eventType?: string;
+        payload?: Record<string, any>;
+        metadata?: Record<string, any>;
+    }>;
+    autoCreateInstance?: boolean;
+}
+export interface EventLogInstanceResponse extends EventLogBaseResponse {
+    data?: {
+        instance: EventLogInstance;
+    };
+}
+export interface EventLogInstanceListResponse extends EventLogBaseResponse {
+    data?: {
+        instances: EventLogInstance[];
+    };
+}
+export interface EventLogAppendResponse extends EventLogBaseResponse {
+    data?: {
+        event: EventLogEntry;
+    };
+}
+export interface EventLogAppendMultipleResponse extends EventLogBaseResponse {
+    data?: {
+        events: EventLogEntry[];
+        count: number;
+    };
+}
+export interface EventLogQueryResponse extends EventLogBaseResponse {
+    data?: {
+        result: EventLogQueryResult;
+    };
+}
+export interface EventLogStatsResponse extends EventLogBaseResponse {
+    data?: {
+        instanceId: string;
+        name: string;
+        eventCount: number;
+        createdAt: string;
+        updatedAt: string;
+    };
+}

package/dist/types/eventLog.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Event Log Types
+ * Type definitions for event log operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/fileUpdateIntent.d.ts

@@ -0,0 +1,130 @@
+/**
+ * File Update Intent Types for Multi-Agent Coordination
+ * Allows agents to declare files they intend to modify before starting work
+ */
+/**
+ * Intent Level - determines behavior on overlap
+ * 1 = Advisory/Notification - Just informs others; no enforcement. Overlapping agents proceed but log warning.
+ * 2 = Soft Reservation - Prefer avoidance: Agents should pick another task or negotiate if overlap.
+ * 3 = Priority-Based - Higher-priority intent wins; lower one backs off or escalates.
+ * 4 = Hard Lock - Blocks others entirely (fallback to traditional locking).
+ */
+export type IntentLevel = 1 | 2 | 3 | 4;
+export declare const INTENT_LEVEL_INFO: Record<IntentLevel, {
+    name: string;
+    behavior: string;
+    useCase: string;
+    color: string;
+}>;
+/**
+ * File-level intent detail
+ */
+export interface FileIntent {
+    filePath: string;
+    intentLevel: IntentLevel;
+    targetSections?: string[];
+}
+/**
+ * Intent status
+ */
+export type IntentStatus = 'active' | 'completed' | 'expired' | 'cancelled';
+/**
+ * Main File Update Intent
+ */
+export interface FileUpdateIntent {
+    id: string;
+    environmentId: string;
+    files: FileIntent[];
+    description: string;
+    estimatedDuration?: number;
+    priority: number;
+    claimedBy: string;
+    claimedByName?: string;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt?: string;
+    autoExpire: boolean;
+    maxAutoExpireMinutes?: number;
+    status: IntentStatus;
+    closedAt?: string;
+    closedBy?: string;
+}
+/**
+ * Request to create a file update intent
+ */
+export interface CreateFileUpdateIntentRequest {
+    environmentId: string;
+    files: FileIntent[];
+    description: string;
+    estimatedDuration?: number;
+    priority?: number;
+    autoExpire?: boolean;
+    maxAutoExpireMinutes?: number;
+}
+/**
+ * Request to update a file update intent
+ */
+export interface UpdateFileUpdateIntentRequest {
+    files?: FileIntent[];
+    description?: string;
+    estimatedDuration?: number;
+    priority?: number;
+    autoExpire?: boolean;
+    maxAutoExpireMinutes?: number;
+}
+/**
+ * Overlapping intent info
+ */
+export interface OverlappingIntentInfo {
+    intentId: string;
+    claimedBy: string;
+    claimedByName?: string;
+    files: string[];
+    intentLevels: IntentLevel[];
+    priority: number;
+}
+/**
+ * Response for overlap detection
+ */
+export interface IntentOverlapResult {
+    hasOverlap: boolean;
+    overlappingIntents: OverlappingIntentInfo[];
+    blockedFiles: string[];
+    canProceed: boolean;
+    message?: string;
+}
+/**
+ * Filter options for listing intents
+ */
+export interface FileUpdateIntentFilters {
+    environmentId?: string;
+    status?: IntentStatus[];
+    claimedBy?: string;
+    filePathContains?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+}
+/**
+ * Response types for API calls
+ */
+export interface FileUpdateIntentResponse {
+    intent?: FileUpdateIntent;
+    overlap?: IntentOverlapResult;
+}
+export interface FileUpdateIntentListResponse {
+    intents: FileUpdateIntent[];
+}
+export interface FileUpdateIntentOverlapResponse {
+    result: IntentOverlapResult;
+}
+export interface FileUpdateIntentBlockedFilesResponse {
+    blockedFiles: string[];
+}
+export interface FileWithIntent {
+    filePath: string;
+    intentId: string;
+    claimedBy: string;
+    claimedByName?: string;
+    intentLevel: IntentLevel;
+    priority: number;
+}

package/dist/types/fileUpdateIntent.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * File Update Intent Types for Multi-Agent Coordination
+ * Allows agents to declare files they intend to modify before starting work
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTENT_LEVEL_INFO = void 0;
+exports.INTENT_LEVEL_INFO = {
+    1: {
+        name: 'Advisory/Notification',
+        behavior: 'Just informs others; no enforcement. Overlapping agents proceed but log warning.',
+        useCase: 'Low-risk, exploratory tasks',
+        color: '#3B82F6', // Blue
+    },
+    2: {
+        name: 'Soft Reservation',
+        behavior: 'Prefer avoidance: Agents should pick another task or negotiate if overlap.',
+        useCase: 'Default for most coding swarms',
+        color: '#F59E0B', // Amber
+    },
+    3: {
+        name: 'Priority-Based',
+        behavior: 'Higher-priority intent wins; lower one backs off or escalates.',
+        useCase: 'Urgent fixes vs. features',
+        color: '#8B5CF6', // Purple
+    },
+    4: {
+        name: 'Hard Lock',
+        behavior: 'Blocks others entirely (fallback to traditional locking).',
+        useCase: 'Critical/shared resources',
+        color: '#DC2626', // Red
+    },
+};