turboflux 1.0.0

package/dist/shared/pluginTypes.d.ts

@@ -0,0 +1,345 @@
+export type PluginID = string;
+export type PluginVersion = string;
+export type SemVer = `${number}.${number}.${number}`;
+export interface PluginAuthor {
+    name: string;
+    email?: string;
+    url?: string;
+}
+export interface PluginManifest {
+    id: PluginID;
+    name: string;
+    description: string;
+    version: PluginVersion;
+    author: PluginAuthor;
+    license?: string;
+    icon?: string;
+    homepage?: string;
+    repository?: string;
+    engines?: {
+        turboforge: string;
+        turboflux?: string;
+    };
+    categories?: PluginCategory[];
+    keywords?: string[];
+    activationEvents?: ActivationEvent[];
+    contributes?: PluginContributes;
+    permissions?: PluginPermission[];
+    dependencies?: Record<PluginID, string>;
+    main?: string;
+}
+export type PluginCategory = 'ai-model' | 'theme' | 'language' | 'tool' | 'integration' | 'productivity' | 'custom';
+export type ActivationEvent = '*' | 'onStartupFinished' | 'onCommand:<id>' | 'onView:<id>' | 'onFile:<glob>' | 'onLanguage:<lang>' | 'onMode:<mode>' | 'onTask:<type>';
+export interface PluginContributes {
+    commands?: PluginCommand[];
+    configuration?: PluginConfiguration[];
+    menus?: PluginMenus;
+    keybindings?: PluginKeybinding[];
+    themes?: PluginTheme[];
+    tools?: PluginTool[];
+    agents?: PluginAgent[];
+    skills?: PluginSkill[];
+    hooks?: PluginHooks;
+    views?: PluginView[];
+    viewsContainers?: PluginViewsContainer[];
+}
+export interface PluginCommand {
+    id: string;
+    title: string;
+    category?: string;
+    icon?: string;
+    when?: string;
+}
+export interface PluginConfiguration {
+    id: string;
+    title: string;
+    properties: Record<string, ConfigProperty>;
+}
+export interface ConfigProperty {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    default?: unknown;
+    description?: string;
+    enum?: unknown[];
+    enumDescriptions?: string[];
+    minimum?: number;
+    maximum?: number;
+}
+export interface PluginMenus {
+    'commandPalette'?: MenuItem[];
+    'editor/context'?: MenuItem[];
+    'explorer/context'?: MenuItem[];
+    'sidebar/activity'?: MenuItem[];
+    'statusBar'?: MenuItem[];
+}
+export interface MenuItem {
+    command: string;
+    when?: string;
+    group?: string;
+}
+export interface PluginKeybinding {
+    command: string;
+    key: string;
+    when?: string;
+    mac?: string;
+    linux?: string;
+    win?: string;
+}
+export interface PluginTheme {
+    id: string;
+    label: string;
+    uiTheme: 'vs' | 'vs-dark' | 'hc-black';
+    path: string;
+}
+export interface PluginTool {
+    id: string;
+    name: string;
+    description: string;
+    icon?: string;
+    parameters?: ToolParameter[];
+    handler: string;
+}
+export interface ToolParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description: string;
+    required?: boolean;
+    default?: unknown;
+}
+export interface PluginAgent {
+    id: string;
+    name: string;
+    description: string;
+    icon?: string;
+    systemPrompt?: string;
+    tools?: string[];
+    model?: string;
+}
+export interface PluginSkill {
+    id: string;
+    name: string;
+    command: string;
+    description: string;
+    icon?: string;
+    category: SkillCategory;
+    systemPrompt?: string;
+    promptPath?: string;
+    capabilities?: {
+        can: string[];
+        cannot: string[];
+    };
+    principles?: string[];
+    tools?: SkillTool[];
+    outputFormat?: string;
+    examples?: SkillExample[];
+    autoTrigger?: {
+        onFile?: string;
+        onMode?: string;
+        onTask?: string;
+    };
+}
+export type SkillCategory = 'core' | 'design' | 'code-quality' | 'engineering' | 'ai-ml' | 'devops' | 'security' | 'custom';
+export interface SkillTool {
+    name: string;
+    description: string;
+    parameters?: ToolParameter[];
+}
+export interface SkillExample {
+    input: string;
+    output?: string;
+    description?: string;
+}
+export interface PluginHooks {
+    preTask?: string;
+    postTask?: string;
+    preToolUse?: string;
+    postToolUse?: string;
+    onModeChange?: string;
+    onFileChange?: string;
+}
+export interface PluginView {
+    id: string;
+    name: string;
+    when?: string;
+    icon?: string;
+}
+export interface PluginViewsContainer {
+    id: string;
+    title: string;
+    icon: string;
+}
+export type PluginPermission = 'filesystem.read' | 'filesystem.write' | 'network' | 'terminal' | 'clipboard' | 'notifications' | 'webview' | 'ai' | 'storage' | 'process' | 'unsafe-eval';
+export type PluginState = 'installing' | 'installed' | 'enabling' | 'enabled' | 'disabling' | 'disabled' | 'uninstalling' | 'error';
+export interface LoadedPlugin {
+    id: PluginID;
+    manifest: PluginManifest;
+    path: string;
+    source: string;
+    state: PluginState;
+    enabled: boolean;
+    installedAt: string;
+    updatedAt: string;
+    error?: string;
+    isBuiltin?: boolean;
+    isDevelopment?: boolean;
+}
+export interface PluginMarketplace {
+    id: string;
+    name: string;
+    description?: string;
+    url: string;
+    icon?: string;
+    trusted?: boolean;
+    autoUpdate?: boolean;
+}
+export interface MarketplacePlugin {
+    id: PluginID;
+    manifest: PluginManifest;
+    downloadUrl: string;
+    readme?: string;
+    changelog?: string;
+    downloadCount: number;
+    rating: number;
+    reviewCount: number;
+    lastUpdated: string;
+}
+export interface PluginMessage {
+    type: string;
+    payload?: unknown;
+}
+export interface PluginAPI {
+    storage: {
+        get<T>(key: string): Promise<T | undefined>;
+        set<T>(key: string, value: T): Promise<void>;
+        remove(key: string): Promise<void>;
+    };
+    filesystem: {
+        readFile(path: string): Promise<string>;
+        writeFile(path: string, content: string): Promise<void>;
+        readDirectory(path: string): Promise<string[]>;
+        exists(path: string): Promise<boolean>;
+        delete(path: string): Promise<void>;
+        mkdir(path: string): Promise<void>;
+    };
+    window: {
+        showInformationMessage(message: string): Promise<void>;
+        showWarningMessage(message: string): Promise<void>;
+        showErrorMessage(message: string): Promise<void>;
+        showInputBox(options: {
+            prompt?: string;
+            placeholder?: string;
+            value?: string;
+        }): Promise<string | undefined>;
+        showQuickPick(items: string[], options?: {
+            placeholder?: string;
+        }): Promise<string | undefined>;
+    };
+    ai: {
+        invokeTool(toolId: string, params: unknown): Promise<unknown>;
+        createAgent(config: Partial<PluginAgent>): Promise<string>;
+        invokeSkill(skillId: string, params?: unknown): Promise<unknown>;
+        getAvailableModels(): Promise<string[]>;
+    };
+    tasks: {
+        createTask(type: string, data: unknown): Promise<string>;
+        onDidCreateTask(callback: (task: unknown) => void): () => void;
+        updateTask(taskId: string, updates: unknown): Promise<void>;
+        completeTask(taskId: string): Promise<void>;
+    };
+    events: {
+        on(event: string, callback: (data: unknown) => void): () => void;
+        emit(event: string, data?: unknown): void;
+        once(event: string, callback: (data: unknown) => void): () => void;
+    };
+    commands: {
+        registerCommand(id: string, handler: (...args: unknown[]) => unknown): void;
+        executeCommand(id: string, ...args: unknown[]): Promise<unknown>;
+        getCommands(): string[];
+    };
+    tools: {
+        registerTool(tool: PluginTool, handler: (params: unknown) => Promise<unknown>): void;
+        invokeTool(toolId: string, params: unknown): Promise<unknown>;
+        getTools(): PluginTool[];
+    };
+    skills: {
+        registerSkill(skill: PluginSkill): void;
+        invokeSkill(skillId: string, context?: unknown): Promise<unknown>;
+        getSkills(): PluginSkill[];
+        getSkillByCommand(command: string): PluginSkill | undefined;
+    };
+    vendor: {
+        imageProcessor: {
+            isAvailable(): boolean;
+            sharp(input: Buffer): SharpInstance;
+            readClipboardImage?(maxWidth?: number, maxHeight?: number): Promise<ClipboardImageResult | null>;
+            hasClipboardImage?(): boolean;
+        };
+        audioCapture: {
+            isAvailable(): boolean;
+            startRecording(onData: (data: Buffer) => void, onEnd: () => void): boolean;
+            stopRecording(): void;
+            isRecording(): boolean;
+            startPlayback(sampleRate: number, channels: number): boolean;
+            writePlaybackData(data: Buffer): void;
+            stopPlayback(): void;
+            isPlaying(): boolean;
+            microphoneAuthorizationStatus(): number;
+        };
+        urlHandler: {
+            isAvailable(): boolean;
+            registerUrlHandler(): Promise<boolean>;
+            getLaunchUrl(): string | null;
+            onOpenUrl(callback: (url: string) => void): () => void;
+        };
+        modifiers: {
+            isAvailable(): boolean;
+            getModifiers(): string[];
+            isModifierPressed(modifier: string): boolean;
+        };
+    };
+}
+export interface SharpInstance {
+    metadata(): Promise<{
+        width: number;
+        height: number;
+        format: string;
+    }>;
+    resize(width: number, height: number, options?: {
+        fit?: string;
+        withoutEnlargement?: boolean;
+    }): SharpInstance;
+    jpeg(options?: {
+        quality?: number;
+    }): SharpInstance;
+    png(options?: {
+        compressionLevel?: number;
+        palette?: boolean;
+        colors?: number;
+    }): SharpInstance;
+    webp(options?: {
+        quality?: number;
+    }): SharpInstance;
+    toBuffer(): Promise<Buffer>;
+}
+export interface ClipboardImageResult {
+    png: Buffer;
+    originalWidth: number;
+    originalHeight: number;
+    width: number;
+    height: number;
+}
+export interface PluginContext {
+    id: PluginID;
+    manifest: PluginManifest;
+    path: string;
+    api: PluginAPI;
+    logger: {
+        info: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+    };
+}
+export interface PluginModule {
+    activate?(context: PluginContext): Promise<void> | void;
+    deactivate?(): Promise<void> | void;
+}

package/dist/shared/pluginTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pluginTypes.js.map

package/dist/shared/pluginTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginTypes.js","sourceRoot":"","sources":["../../src/shared/pluginTypes.ts"],"names":[],"mappings":""}

package/dist/shared/runtimeTaskTypes.d.ts

@@ -0,0 +1,43 @@
+export type RuntimeTaskKind = 'shell' | 'terminal' | 'agent' | 'mcp' | 'workflow' | 'remote';
+export type RuntimeTaskStatus = 'starting' | 'running' | 'stopping' | 'completed' | 'failed' | 'stopped' | 'interrupted' | 'orphaned';
+export type RuntimeRestartPolicy = 'never' | 'on-failure' | 'always';
+export interface RuntimeTask {
+    id: string;
+    kind: RuntimeTaskKind;
+    ownerSessionId?: string;
+    parentTaskId?: string;
+    status: RuntimeTaskStatus;
+    command?: string;
+    cwd?: string;
+    pid?: number;
+    startedAt: number;
+    updatedAt: number;
+    endedAt?: number;
+    exitCode?: number | null;
+    logPath?: string;
+    outputOffset?: number;
+    outputBytes?: number;
+    interactive: boolean;
+    restartPolicy: RuntimeRestartPolicy;
+    error?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface RuntimeTaskFilter {
+    kind?: RuntimeTaskKind;
+    status?: RuntimeTaskStatus;
+    ownerSessionId?: string;
+    parentTaskId?: string;
+}
+export type RuntimeTaskEvent = {
+    type: 'runtime-task:created';
+    task: RuntimeTask;
+} | {
+    type: 'runtime-task:updated';
+    task: RuntimeTask;
+} | {
+    type: 'runtime-task:finished';
+    task: RuntimeTask;
+} | {
+    type: 'runtime-task:removed';
+    taskId: string;
+};

package/dist/shared/runtimeTaskTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtimeTaskTypes.js.map

package/dist/shared/runtimeTaskTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeTaskTypes.js","sourceRoot":"","sources":["../../src/shared/runtimeTaskTypes.ts"],"names":[],"mappings":""}

package/dist/shared/skillTypes.d.ts

@@ -0,0 +1 @@
+export type { PluginSkill as Skill, SkillCategory } from './pluginTypes';

package/dist/shared/skillTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=skillTypes.js.map

package/dist/shared/skillTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillTypes.js","sourceRoot":"","sources":["../../src/shared/skillTypes.ts"],"names":[],"mappings":""}

package/dist/shared/subAgentTypes.d.ts

@@ -0,0 +1,99 @@
+export type SubAgentDriver = 'main-model' | 'deepseek-flash' | 'deepseek-reasoner';
+export type SubAgentThinking = 'disabled' | 'high' | 'max';
+export interface SubAgentDefinition {
+    id: string;
+    label: string;
+    description: string;
+    driver: SubAgentDriver;
+    systemPrompt: string;
+    maxTurns: number;
+    maxParallel: number;
+    maxOutputTokens?: number;
+    temperature?: number;
+    thinking?: SubAgentThinking;
+}
+export interface SubAgentEvidence {
+    path: string;
+    startLine: number;
+    endLine: number;
+    preview: string;
+    content?: string;
+    reason: string;
+    kind?: 'entry' | 'implementation' | 'caller' | 'config' | 'schema' | 'test' | 'root_cause' | 'supporting';
+    score?: number;
+    confidence?: 'high' | 'medium' | 'low';
+    symbol?: string;
+}
+export type SubAgentEvent = {
+    type: 'turn_start';
+    turn: number;
+    maxTurns: number;
+} | {
+    type: 'model_wait';
+    turn: number;
+    elapsedMs: number;
+    timeoutMs: number;
+} | {
+    type: 'model_retry';
+    turn: number;
+    attempt: number;
+    delayMs: number;
+    reason: string;
+} | {
+    type: 'model_response';
+    turn: number;
+    protocol: string;
+    offeredTools: string[];
+    returnedTools: string[];
+} | {
+    type: 'turn_complete';
+    turn: number;
+    calls: number;
+    modelElapsedMs?: number;
+    toolElapsedMs?: number;
+    totalElapsedMs?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    reasoningTokens?: number;
+} | {
+    type: 'tool_call';
+    tool: string;
+    args: unknown;
+    turn: number;
+} | {
+    type: 'tool_result';
+    tool: string;
+    ok: boolean;
+    summary: string;
+    turn: number;
+    elapsedMs?: number;
+    operations?: number;
+    readOperations?: number;
+} | {
+    type: 'evidence';
+    evidence: SubAgentEvidence;
+} | {
+    type: 'final';
+    text: string;
+} | {
+    type: 'error';
+    message: string;
+};
+export interface SubAgentInvocation {
+    definition: SubAgentDefinition;
+    objective: string;
+    workspacePath: string;
+    codemap?: string;
+    abortSignal?: AbortSignal;
+    onEvent?: (event: SubAgentEvent) => void;
+}
+export interface SubAgentResult {
+    ok: boolean;
+    finalText: string;
+    evidence: SubAgentEvidence[];
+    turns: number;
+    elapsedMs: number;
+    truncated: boolean;
+    error?: string;
+}

package/dist/shared/subAgentTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subAgentTypes.js.map

package/dist/shared/subAgentTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subAgentTypes.js","sourceRoot":"","sources":["../../src/shared/subAgentTypes.ts"],"names":[],"mappings":""}

package/dist/shared/terminalTypes.d.ts

@@ -0,0 +1,102 @@
+export type TerminalSessionStatus = 'starting' | 'running' | 'exited' | 'error';
+export interface TerminalShellInfo {
+    id: string;
+    label: string;
+    command: string;
+    args?: string[];
+    available: boolean;
+    reason?: string;
+}
+export interface TerminalOutputChunk {
+    seq: number;
+    data: string;
+    timestamp: number;
+}
+export interface TerminalSessionInfo {
+    id: string;
+    pid: number;
+    shell: string;
+    shellId: string;
+    shellLabel: string;
+    cwd: string;
+    status: TerminalSessionStatus;
+    createdAt: number;
+    updatedAt: number;
+    isAgentSession: boolean;
+    title: string;
+    command?: string;
+    runtimeTaskId?: string;
+    logPath?: string;
+    outputBytes?: number;
+    omittedBytes?: number;
+    firstSeq?: number;
+    lastSeq?: number;
+    recovered?: boolean;
+    canWrite?: boolean;
+    exitCode?: number | null;
+    exitSignal?: string | null;
+    error?: string;
+}
+export interface TerminalCreateOptions {
+    shell?: string;
+    cwd?: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+    isAgentSession?: boolean;
+}
+export interface TerminalCreateResult {
+    success: boolean;
+    session?: TerminalSessionInfo;
+    id?: string;
+    pid?: number;
+    shell?: string;
+    cwd?: string;
+    error?: string;
+}
+export interface TerminalListResult {
+    success: boolean;
+    sessions?: TerminalSessionInfo[];
+    error?: string;
+}
+export interface TerminalBufferResult {
+    success: boolean;
+    chunks?: TerminalOutputChunk[];
+    session?: TerminalSessionInfo;
+    firstSeq?: number;
+    lastSeq?: number;
+    omittedBytes?: number;
+    error?: string;
+}
+export interface TerminalStartCommandResult {
+    sessionId: string;
+    session: TerminalSessionInfo;
+}
+export interface TerminalShellsResult {
+    success: boolean;
+    shells?: TerminalShellInfo[];
+    defaultShellId?: string;
+    error?: string;
+}
+export interface TerminalRunCommandResult {
+    success: boolean;
+    output?: string;
+    exitCode?: number | null;
+    completed?: boolean;
+    error?: string;
+}
+export interface TerminalDataEvent {
+    sessionId: string;
+    data: string;
+    seq: number;
+    timestamp: number;
+}
+export interface TerminalExitEvent {
+    sessionId: string;
+    exitCode: number | null;
+    exitSignal?: string | null;
+    timestamp: number;
+}
+export interface TerminalStatusEvent {
+    session: TerminalSessionInfo;
+}

package/dist/shared/terminalTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=terminalTypes.js.map

package/dist/shared/terminalTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminalTypes.js","sourceRoot":"","sources":["../../src/shared/terminalTypes.ts"],"names":[],"mappings":""}

package/dist/shared/toolCallMarkup.d.ts

@@ -0,0 +1,10 @@
+import type { ToolCall } from './agentTypes';
+export interface TextToolCallParseResult {
+    toolCalls: ToolCall[];
+    cleanedText: string;
+    containsToolMarkup: boolean;
+}
+export declare function stripTextToolCallMarkup(text: string, options?: {
+    stripIncomplete?: boolean;
+}): string;
+export declare function parseTextToolCalls(text: string): TextToolCallParseResult;