@kairos-sdk/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,417 @@
+interface Tag {
+    id: string;
+    name: string;
+}
+interface N8nCredentialReference {
+    id: string;
+    name: string;
+}
+type ConnectionPort = {
+    node: string;
+    type: string;
+    index: number;
+};
+type ConnectionPortList = ConnectionPort[];
+interface N8nConnections {
+    [nodeName: string]: {
+        main?: ConnectionPortList[];
+        ai_languageModel?: ConnectionPortList[];
+        ai_memory?: ConnectionPortList[];
+        ai_tool?: ConnectionPortList[];
+        ai_document?: ConnectionPortList[];
+        ai_embedding?: ConnectionPortList[];
+        ai_vectorStore?: ConnectionPortList[];
+        ai_retriever?: ConnectionPortList[];
+        ai_outputParser?: ConnectionPortList[];
+        ai_textSplitter?: ConnectionPortList[];
+        [key: string]: ConnectionPortList[] | undefined;
+    };
+}
+interface N8nNode {
+    id: string;
+    name: string;
+    type: string;
+    typeVersion: number;
+    position: [number, number];
+    parameters: Record<string, unknown>;
+    credentials?: Record<string, N8nCredentialReference>;
+    disabled?: boolean;
+    notes?: string;
+    notesInFlow?: boolean;
+    continueOnFail?: boolean;
+    retryOnFail?: boolean;
+    maxTries?: number;
+    waitBetweenTries?: number;
+}
+interface N8nSettings {
+    executionOrder?: 'v0' | 'v1';
+    saveManualExecutions?: boolean;
+    callerPolicy?: string;
+    errorWorkflow?: string;
+    timezone?: string;
+    [key: string]: unknown;
+}
+interface N8nWorkflow {
+    name: string;
+    nodes: N8nNode[];
+    connections: N8nConnections;
+    settings?: N8nSettings;
+    tags?: Tag[];
+}
+
+interface CredentialRequirement {
+    service: string;
+    credentialType: string;
+    description: string;
+}
+interface BuildResult {
+    workflowId: string | null;
+    name: string;
+    credentialsNeeded: CredentialRequirement[];
+    activationRequired: boolean;
+    generationAttempts: number;
+    dryRun: boolean;
+}
+interface DeployResult {
+    workflowId: string;
+    name: string;
+}
+interface WorkflowListItem {
+    id: string;
+    name: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+    tags?: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+interface ExecutionSummary {
+    id: string;
+    workflowId: string;
+    status: 'success' | 'error' | 'waiting' | 'running' | 'canceled';
+    startedAt: string;
+    stoppedAt?: string;
+    mode: string;
+}
+interface ExecutionDetail extends ExecutionSummary {
+    data?: unknown;
+    workflowData?: unknown;
+}
+
+interface ILogger {
+    debug(msg: string, meta?: Record<string, unknown>): void;
+    info(msg: string, meta?: Record<string, unknown>): void;
+    warn(msg: string, meta?: Record<string, unknown>): void;
+    error(msg: string, meta?: Record<string, unknown>): void;
+}
+declare const nullLogger: ILogger;
+
+interface WorkflowMetadataInput {
+    description: string;
+    tags?: string[];
+    platform?: string;
+}
+interface StoredWorkflow {
+    id: string;
+    workflow: N8nWorkflow;
+    description: string;
+    tags: string[];
+    platform: string;
+    deployCount: number;
+    createdAt: string;
+    lastDeployedAt?: string;
+}
+interface WorkflowMatch {
+    workflow: StoredWorkflow;
+    score: number;
+    mode: 'direct' | 'reference' | 'scratch';
+}
+interface SearchOptions {
+    limit?: number;
+    platform?: string;
+}
+interface LibraryFilters {
+    platform?: string;
+    tags?: string[];
+}
+interface IWorkflowLibrary {
+    initialize(): Promise<void>;
+    search(description: string, options?: SearchOptions): Promise<WorkflowMatch[]>;
+    save(workflow: N8nWorkflow, metadata: WorkflowMetadataInput): Promise<string>;
+    recordDeployment(id: string): Promise<void>;
+    get(id: string): Promise<StoredWorkflow | null>;
+    list(filters?: LibraryFilters): Promise<StoredWorkflow[]>;
+}
+
+interface ClientOptions {
+    anthropicApiKey: string;
+    n8nBaseUrl: string;
+    n8nApiKey: string;
+    model?: string;
+    logger?: ILogger;
+    library?: IWorkflowLibrary;
+    telemetry?: boolean | string;
+}
+interface BuildOptions {
+    dryRun?: boolean;
+    activate?: boolean;
+    name?: string;
+}
+interface DeleteOptions {
+    confirm: true;
+}
+interface ExecutionFilter {
+    status?: 'success' | 'error' | 'waiting' | 'running';
+    limit?: number;
+    cursor?: string;
+}
+
+declare class Kairos {
+    private readonly provider;
+    private readonly designer;
+    private readonly validator;
+    private readonly library;
+    private readonly logger;
+    private readonly telemetry;
+    private readonly model;
+    constructor(options: ClientOptions);
+    build(description: string, options?: BuildOptions): Promise<BuildResult>;
+    update(id: string, description: string): Promise<BuildResult>;
+    get(id: string): Promise<N8nWorkflow>;
+    list(): Promise<WorkflowListItem[]>;
+    activate(id: string): Promise<void>;
+    deactivate(id: string): Promise<void>;
+    delete(id: string, options: DeleteOptions): Promise<void>;
+    executions(workflowId?: string, filter?: ExecutionFilter): Promise<ExecutionSummary[]>;
+    execution(id: string): Promise<ExecutionDetail>;
+    listTags(): Promise<Tag[]>;
+    createTag(name: string): Promise<Tag>;
+    tag(workflowId: string, tagIds: string[]): Promise<void>;
+    untag(workflowId: string, tagIds: string[]): Promise<void>;
+}
+
+interface IProvider {
+    readonly platform: string;
+    deploy(workflow: N8nWorkflow): Promise<DeployResult>;
+    update(id: string, workflow: N8nWorkflow): Promise<DeployResult>;
+    get(id: string): Promise<N8nWorkflow>;
+    list(): Promise<WorkflowListItem[]>;
+    activate(id: string): Promise<void>;
+    deactivate(id: string): Promise<void>;
+    delete(id: string, options: DeleteOptions): Promise<void>;
+    executions(workflowId?: string, filter?: ExecutionFilter): Promise<ExecutionSummary[]>;
+    execution(id: string): Promise<ExecutionDetail>;
+    tag(workflowId: string, tagIds: string[]): Promise<void>;
+    untag(workflowId: string, tagIds: string[]): Promise<void>;
+    listTags(): Promise<Tag[]>;
+    createTag(name: string): Promise<Tag>;
+}
+
+interface N8nWorkflowResponse {
+    id: string;
+    name: string;
+    active: boolean;
+    nodes: N8nNode[];
+    connections: N8nConnections;
+    settings?: N8nSettings;
+    tags?: Tag[];
+    createdAt: string;
+    updatedAt: string;
+    versionId?: string;
+    meta?: Record<string, unknown>;
+    pinData?: Record<string, unknown>;
+    staticData?: unknown;
+    triggerCount?: number;
+    shared?: boolean;
+    isArchived?: boolean;
+}
+
+declare class N8nApiClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly logger;
+    constructor(baseUrl: string, apiKey: string, logger: ILogger);
+    private request;
+    createWorkflow(workflow: N8nWorkflow): Promise<N8nWorkflowResponse>;
+    updateWorkflow(id: string, workflow: N8nWorkflow): Promise<N8nWorkflowResponse>;
+    getWorkflow(id: string): Promise<N8nWorkflowResponse>;
+    listWorkflows(): Promise<WorkflowListItem[]>;
+    deleteWorkflow(id: string): Promise<void>;
+    activateWorkflow(id: string): Promise<void>;
+    deactivateWorkflow(id: string): Promise<void>;
+    getExecutions(workflowId?: string, filter?: ExecutionFilter): Promise<ExecutionSummary[]>;
+    getExecution(id: string): Promise<ExecutionDetail>;
+    listTags(): Promise<Tag[]>;
+    createTag(name: string): Promise<Tag>;
+    tagWorkflow(workflowId: string, tagIds: string[]): Promise<void>;
+    untagWorkflow(workflowId: string, tagIds: string[]): Promise<void>;
+    private mapExecution;
+}
+
+declare class N8nFieldStripper {
+    stripForCreate(workflow: N8nWorkflow): N8nWorkflow;
+    stripForUpdate(workflow: N8nWorkflow): N8nWorkflow;
+    private strip;
+}
+
+declare class N8nProvider implements IProvider {
+    private readonly client;
+    private readonly stripper;
+    readonly platform = "n8n";
+    constructor(client: N8nApiClient, stripper: N8nFieldStripper);
+    deploy(workflow: N8nWorkflow): Promise<DeployResult>;
+    update(id: string, workflow: N8nWorkflow): Promise<DeployResult>;
+    get(id: string): Promise<N8nWorkflow>;
+    list(): Promise<WorkflowListItem[]>;
+    activate(id: string): Promise<void>;
+    deactivate(id: string): Promise<void>;
+    delete(id: string, options: DeleteOptions): Promise<void>;
+    executions(workflowId?: string, filter?: ExecutionFilter): Promise<ExecutionSummary[]>;
+    execution(id: string): Promise<ExecutionDetail>;
+    listTags(): Promise<Tag[]>;
+    createTag(name: string): Promise<Tag>;
+    tag(workflowId: string, tagIds: string[]): Promise<void>;
+    untag(workflowId: string, tagIds: string[]): Promise<void>;
+}
+
+declare class NullLibrary implements IWorkflowLibrary {
+    initialize(): Promise<void>;
+    search(_description: string, _options?: SearchOptions): Promise<WorkflowMatch[]>;
+    save(_workflow: N8nWorkflow, _metadata: WorkflowMetadataInput): Promise<string>;
+    recordDeployment(_id: string): Promise<void>;
+    get(_id: string): Promise<StoredWorkflow | null>;
+    list(_filters?: LibraryFilters): Promise<StoredWorkflow[]>;
+}
+
+declare class FileLibrary implements IWorkflowLibrary {
+    private readonly dir;
+    private workflows;
+    private initialized;
+    constructor(dir?: string);
+    initialize(): Promise<void>;
+    search(description: string, options?: SearchOptions): Promise<WorkflowMatch[]>;
+    save(workflow: N8nWorkflow, metadata: WorkflowMetadataInput): Promise<string>;
+    recordDeployment(id: string): Promise<void>;
+    get(id: string): Promise<StoredWorkflow | null>;
+    list(filters?: LibraryFilters): Promise<StoredWorkflow[]>;
+    private persist;
+}
+
+interface ValidationIssue$1 {
+    rule: number;
+    severity: 'error' | 'warn';
+    message: string;
+    nodeId?: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    issues: ValidationIssue$1[];
+}
+
+interface NodeDefinition {
+    type: string;
+    safeTypeVersions: number[];
+    requiredParams: string[];
+    credentialType?: string;
+    isTrigger?: boolean;
+}
+declare const DEFAULT_REGISTRY: NodeDefinition[];
+declare class NodeRegistry {
+    private readonly byType;
+    constructor(definitions?: NodeDefinition[]);
+    get(type: string): NodeDefinition | undefined;
+    isTrigger(type: string): boolean;
+    isVersionSafe(type: string, version: number): boolean;
+}
+
+declare class N8nValidator {
+    private readonly registry;
+    constructor(registry?: NodeRegistry);
+    validate(workflow: N8nWorkflow): ValidationResult;
+    private err;
+    private warn;
+    private isTriggerNode;
+    private checkRule1;
+    private checkRule2;
+    private checkRule3;
+    private checkRule4;
+    private checkRule5;
+    private checkRule6;
+    private checkRule7;
+    private checkRule8;
+    private checkRule9;
+    private checkRule10;
+    private checkRule11;
+    private checkRule12;
+    private checkRule13;
+    private checkRule14;
+    private checkRule15;
+    private checkRule16;
+    private checkRule17;
+    private checkRule18;
+    private checkRule19;
+}
+
+declare class KairosError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+
+interface ValidationIssue {
+    rule: number;
+    severity: 'error' | 'warn';
+    message: string;
+    nodeId?: string;
+}
+declare class ValidationError extends KairosError {
+    readonly issues: ValidationIssue[];
+    constructor(message: string, issues: ValidationIssue[]);
+}
+
+declare class GenerationError extends KairosError {
+    constructor(message: string, cause?: unknown);
+}
+
+declare class ResponseParseError extends KairosError {
+    constructor(message: string, cause?: unknown);
+}
+
+declare class ProviderError extends KairosError {
+    constructor(message: string, cause?: unknown);
+}
+
+declare class ApiError extends KairosError {
+    readonly statusCode: number;
+    constructor(message: string, statusCode: number, cause?: unknown);
+}
+
+declare class GuardError extends KairosError {
+    constructor(message: string);
+}
+
+interface TelemetryEvent {
+    timestamp: string;
+    sessionId: string;
+    eventType: 'build_start' | 'generation_attempt' | 'build_complete';
+    data: Record<string, unknown>;
+}
+interface AttemptMetadata {
+    attempt: number;
+    temperature: number;
+    durationMs: number;
+    tokensInput: number;
+    tokensOutput: number;
+    validationPassed: boolean;
+    issues: ValidationIssue[];
+}
+
+declare class TelemetryCollector {
+    private readonly dir;
+    readonly sessionId: string;
+    constructor(dir?: string);
+    emit(eventType: TelemetryEvent['eventType'], data: Record<string, unknown>): Promise<void>;
+}
+
+export { ApiError, type AttemptMetadata, type BuildOptions, type BuildResult, type ClientOptions, type CredentialRequirement, DEFAULT_REGISTRY, type DeleteOptions, type DeployResult, type ExecutionDetail, type ExecutionFilter, type ExecutionSummary, FileLibrary, GenerationError, GuardError, type ILogger, type IProvider, type IWorkflowLibrary, Kairos, KairosError, N8nApiClient, type N8nConnections, N8nFieldStripper, type N8nNode, N8nProvider, type N8nSettings, N8nValidator, type N8nWorkflow, NodeRegistry, NullLibrary, ProviderError, ResponseParseError, type StoredWorkflow, type Tag, TelemetryCollector, type TelemetryEvent, ValidationError, type ValidationIssue, type ValidationResult, type WorkflowListItem, type WorkflowMatch, nullLogger };