@soederpop/luca 0.1.2 → 0.1.3

package/dist/node/features/python.d.ts

@@ -0,0 +1,477 @@
+import { z } from 'zod';
+import { Feature } from "../feature.js";
+export declare const PythonStateSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    pythonPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    projectDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    environmentType: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        uv: "uv";
+        conda: "conda";
+        venv: "venv";
+        system: "system";
+    }>>>;
+    isReady: z.ZodDefault<z.ZodBoolean>;
+    lastExecutedScript: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    sessionActive: z.ZodDefault<z.ZodBoolean>;
+    sessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export declare const PythonOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    _cacheKey: z.ZodOptional<z.ZodString>;
+    cached: z.ZodOptional<z.ZodBoolean>;
+    enable: z.ZodOptional<z.ZodBoolean>;
+    dir: z.ZodOptional<z.ZodString>;
+    installCommand: z.ZodOptional<z.ZodString>;
+    contextScript: z.ZodOptional<z.ZodString>;
+    pythonPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PythonState = z.infer<typeof PythonStateSchema>;
+export type PythonOptions = z.infer<typeof PythonOptionsSchema>;
+export declare const PythonEventsSchema: z.ZodObject<{
+    stateChange: z.ZodTuple<[z.ZodAny], null>;
+    enabled: z.ZodTuple<[], null>;
+    ready: z.ZodTuple<[], null>;
+    environmentDetected: z.ZodTuple<[z.ZodObject<{
+        pythonPath: z.ZodNullable<z.ZodString>;
+        environmentType: z.ZodNullable<z.ZodEnum<{
+            uv: "uv";
+            conda: "conda";
+            venv: "venv";
+            system: "system";
+        }>>;
+    }, z.core.$strip>], null>;
+    installingDependencies: z.ZodTuple<[z.ZodObject<{
+        command: z.ZodString;
+    }, z.core.$strip>], null>;
+    dependenciesInstalled: z.ZodTuple<[z.ZodObject<{
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        exitCode: z.ZodNumber;
+    }, z.core.$strip>], null>;
+    dependencyInstallFailed: z.ZodTuple<[z.ZodObject<{
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        exitCode: z.ZodNumber;
+    }, z.core.$strip>], null>;
+    codeExecuted: z.ZodTuple<[z.ZodObject<{
+        code: z.ZodString;
+        variables: z.ZodRecord<z.ZodAny, z.core.SomeType>;
+        result: z.ZodObject<{
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            exitCode: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>], null>;
+    fileExecuted: z.ZodTuple<[z.ZodObject<{
+        filePath: z.ZodString;
+        variables: z.ZodRecord<z.ZodAny, z.core.SomeType>;
+        result: z.ZodObject<{
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            exitCode: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>], null>;
+    localsParseError: z.ZodTuple<[z.ZodAny], null>;
+    sessionStarted: z.ZodTuple<[z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>], null>;
+    sessionStopped: z.ZodTuple<[z.ZodObject<{
+        sessionId: z.ZodString;
+    }, z.core.$strip>], null>;
+    sessionError: z.ZodTuple<[z.ZodObject<{
+        error: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>;
+/** Result from a persistent session run() call. */
+export interface RunResult {
+    ok: boolean;
+    result: any;
+    stdout: string;
+    error?: string;
+    traceback?: string;
+}
+/**
+ * The Python VM feature provides Python virtual machine capabilities for executing Python code.
+ *
+ * This feature automatically detects Python environments (uv, conda, venv, system) and provides
+ * methods to install dependencies and execute Python scripts. It can manage project-specific
+ * Python environments and maintain context between executions.
+ *
+ * Supports two modes:
+ * - **Stateless** (default): `execute()` and `executeFile()` spawn a fresh process per call
+ * - **Persistent session**: `startSession()` spawns a long-lived bridge process that maintains
+ *   state across `run()` calls, enabling real codebase interaction with imports and session variables
+ *
+ * @example
+ * ```typescript
+ * const python = container.feature('python', {
+ *   dir: "/path/to/python/project",
+ * })
+ *
+ * // Stateless execution
+ * const result = await python.execute('print("Hello from Python!")')
+ *
+ * // Persistent session
+ * await python.startSession()
+ * await python.run('import myapp.models')
+ * await python.run('users = myapp.models.User.objects.all()')
+ * const result = await python.run('print(len(users))')
+ * await python.stopSession()
+ * ```
+ *
+ * @extends Feature
+ */
+export declare class Python<T extends PythonState = PythonState, K extends PythonOptions = PythonOptions> extends Feature<T, K> {
+    static shortcut: "features.python";
+    static stateSchema: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        pythonPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        projectDir: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        environmentType: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            uv: "uv";
+            conda: "conda";
+            venv: "venv";
+            system: "system";
+        }>>>;
+        isReady: z.ZodDefault<z.ZodBoolean>;
+        lastExecutedScript: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sessionActive: z.ZodDefault<z.ZodBoolean>;
+        sessionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$loose>;
+    static optionsSchema: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        _cacheKey: z.ZodOptional<z.ZodString>;
+        cached: z.ZodOptional<z.ZodBoolean>;
+        enable: z.ZodOptional<z.ZodBoolean>;
+        dir: z.ZodOptional<z.ZodString>;
+        installCommand: z.ZodOptional<z.ZodString>;
+        contextScript: z.ZodOptional<z.ZodString>;
+        pythonPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    static eventsSchema: z.ZodObject<{
+        stateChange: z.ZodTuple<[z.ZodAny], null>;
+        enabled: z.ZodTuple<[], null>;
+        ready: z.ZodTuple<[], null>;
+        environmentDetected: z.ZodTuple<[z.ZodObject<{
+            pythonPath: z.ZodNullable<z.ZodString>;
+            environmentType: z.ZodNullable<z.ZodEnum<{
+                uv: "uv";
+                conda: "conda";
+                venv: "venv";
+                system: "system";
+            }>>;
+        }, z.core.$strip>], null>;
+        installingDependencies: z.ZodTuple<[z.ZodObject<{
+            command: z.ZodString;
+        }, z.core.$strip>], null>;
+        dependenciesInstalled: z.ZodTuple<[z.ZodObject<{
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            exitCode: z.ZodNumber;
+        }, z.core.$strip>], null>;
+        dependencyInstallFailed: z.ZodTuple<[z.ZodObject<{
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+            exitCode: z.ZodNumber;
+        }, z.core.$strip>], null>;
+        codeExecuted: z.ZodTuple<[z.ZodObject<{
+            code: z.ZodString;
+            variables: z.ZodRecord<z.ZodAny, z.core.SomeType>;
+            result: z.ZodObject<{
+                stdout: z.ZodString;
+                stderr: z.ZodString;
+                exitCode: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>], null>;
+        fileExecuted: z.ZodTuple<[z.ZodObject<{
+            filePath: z.ZodString;
+            variables: z.ZodRecord<z.ZodAny, z.core.SomeType>;
+            result: z.ZodObject<{
+                stdout: z.ZodString;
+                stderr: z.ZodString;
+                exitCode: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>], null>;
+        localsParseError: z.ZodTuple<[z.ZodAny], null>;
+        sessionStarted: z.ZodTuple<[z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>], null>;
+        sessionStopped: z.ZodTuple<[z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>], null>;
+        sessionError: z.ZodTuple<[z.ZodObject<{
+            error: z.ZodString;
+            sessionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>], null>;
+    }, z.core.$strip>;
+    private _bridgeProcess;
+    private _bridgeScriptPath;
+    private _pendingRequests;
+    private _stdoutBuffer;
+    get initialState(): T;
+    enable(options?: any): Promise<this>;
+    /** Returns the root directory of the Python project. */
+    get projectDir(): string;
+    /** Returns the path to the Python executable for this environment. */
+    get pythonPath(): "python" | NonNullable<T["pythonPath"]>;
+    /** Returns the detected environment type: 'uv', 'conda', 'venv', or 'system'. */
+    get environmentType(): "system" | NonNullable<T["environmentType"]>;
+    /**
+     * Detects the Python environment type and sets the appropriate Python path.
+     *
+     * This method checks for various Python environment managers in order of preference:
+     * uv, conda, venv, then falls back to system Python. It sets the pythonPath and
+     * environmentType in the state.
+     *
+     * @returns {Promise<void>}
+     *
+     * @example
+     * ```typescript
+     * await python.detectEnvironment()
+     * console.log(python.state.get('environmentType')) // 'uv' | 'conda' | 'venv' | 'system'
+     * console.log(python.state.get('pythonPath')) // '/path/to/python/executable'
+     * ```
+     */
+    detectEnvironment(): Promise<void>;
+    /**
+     * Installs dependencies for the Python project.
+     *
+     * This method automatically detects the appropriate package manager and install command
+     * based on the environment type. If a custom installCommand is provided in options,
+     * it will use that instead.
+     *
+     * @returns {Promise<{ stdout: string; stderr: string; exitCode: number }>}
+     *
+     * @example
+     * ```typescript
+     * // Auto-detect and install
+     * const result = await python.installDependencies()
+     *
+     * // With custom install command
+     * const python = container.feature('python', {
+     *   installCommand: 'pip install -r requirements.txt'
+     * })
+     * const result = await python.installDependencies()
+     * ```
+     */
+    installDependencies(): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    /**
+     * Executes Python code and returns the result.
+     *
+     * This method creates a temporary Python script with the provided code and variables,
+     * executes it using the detected Python environment, and captures the output.
+     *
+     * @param {string} code - The Python code to execute
+     * @param {Record<string, any>} [variables={}] - Variables to make available to the Python code
+     * @param {object} [options] - Execution options
+     * @param {boolean} [options.captureLocals=false] - Whether to capture and return local variables after execution
+     * @returns {Promise<{ stdout: string; stderr: string; exitCode: number; locals?: any }>}
+     *
+     * @example
+     * ```typescript
+     * // Simple execution
+     * const result = await python.execute('print("Hello World")')
+     * console.log(result.stdout) // 'Hello World'
+     *
+     * // With variables
+     * const result = await python.execute('print(f"Hello {name}!")', { name: 'Alice' })
+     *
+     * // Capture locals
+     * const result = await python.execute('x = 42\ny = x * 2', {}, { captureLocals: true })
+     * console.log(result.locals) // { x: 42, y: 84 }
+     * ```
+     */
+    execute(code: string, variables?: Record<string, any>, options?: {
+        captureLocals?: boolean;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        locals?: any;
+    }>;
+    /**
+     * Executes a Python file and returns the result.
+     *
+     * @param {string} filePath - Path to the Python file to execute
+     * @param {Record<string, any>} [variables={}] - Variables to make available via command line arguments
+     * @returns {Promise<{ stdout: string; stderr: string; exitCode: number }>}
+     *
+     * @example
+     * ```typescript
+     * const result = await python.executeFile('/path/to/script.py')
+     * console.log(result.stdout)
+     * ```
+     */
+    executeFile(filePath: string, variables?: Record<string, any>): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+    /**
+     * Gets information about the current Python environment.
+     *
+     * @returns {Promise<{ version: string; path: string; packages: string[] }>}
+     */
+    getEnvironmentInfo(): Promise<{
+        version: string;
+        path: string;
+        packages: string[];
+    }>;
+    /**
+     * Splits the (possibly multi-word) pythonPath into a command and args array
+     * suitable for proc.spawn(). For example, `uv run python` becomes
+     * `{ command: 'uv', args: ['run', 'python', ...extraArgs] }`.
+     */
+    private _parsePythonCommand;
+    /**
+     * Writes the bundled bridge.py to a temp directory and returns its path.
+     * Reuses the same path across calls within a process.
+     */
+    private _ensureBridgeScript;
+    /**
+     * Sends a JSON-line request to the bridge process and returns a promise
+     * that resolves when the matching response (by id) arrives.
+     *
+     * @param type - The request type (exec, eval, import, call, get_locals, reset)
+     * @param payload - Additional fields to include in the request
+     * @param timeout - Timeout in ms (default 30000)
+     */
+    private _sendRequest;
+    /**
+     * Handles incoming stdout data from the bridge process. Buffers partial
+     * lines and parses complete JSON-line responses, resolving their matching
+     * pending requests.
+     */
+    private _onBridgeData;
+    /**
+     * Starts a persistent Python session by spawning the bridge process.
+     *
+     * The bridge sets up sys.path for the project directory, then enters a
+     * JSON-line REPL loop. State (variables, imports) persists across run() calls
+     * until stopSession() or resetSession() is called.
+     *
+     * @example
+     * ```typescript
+     * const python = container.feature('python', { dir: '/path/to/project' })
+     * await python.enable()
+     * await python.startSession()
+     * await python.run('x = 42')
+     * const result = await python.run('print(x)')
+     * console.log(result.stdout) // '42\n'
+     * await python.stopSession()
+     * ```
+     */
+    startSession(): Promise<void>;
+    /**
+     * Stops the persistent Python session and cleans up the bridge process.
+     *
+     * @example
+     * ```typescript
+     * await python.stopSession()
+     * ```
+     */
+    stopSession(): Promise<void>;
+    /**
+     * Executes Python code in the persistent session. Variables and imports
+     * survive across calls. This is the session equivalent of execute().
+     *
+     * @param code - Python code to execute
+     * @param variables - Variables to inject into the namespace before execution
+     * @returns The execution result including captured stdout and any error info
+     *
+     * @example
+     * ```typescript
+     * await python.startSession()
+     *
+     * // State persists across calls
+     * await python.run('x = 42')
+     * const result = await python.run('print(x * 2)')
+     * console.log(result.stdout) // '84\n'
+     *
+     * // Inject variables from JS
+     * const result2 = await python.run('print(f"Hello {name}!")', { name: 'World' })
+     * console.log(result2.stdout) // 'Hello World!\n'
+     * ```
+     */
+    run(code: string, variables?: Record<string, any>): Promise<RunResult>;
+    /**
+     * Evaluates a Python expression in the persistent session and returns its value.
+     *
+     * @param expression - Python expression to evaluate
+     * @returns The evaluated result (JSON-serializable, or repr() string for complex types)
+     *
+     * @example
+     * ```typescript
+     * await python.run('x = 42')
+     * const result = await python.eval('x * 2')
+     * console.log(result) // 84
+     * ```
+     */
+    eval(expression: string): Promise<any>;
+    /**
+     * Imports a Python module into the persistent session namespace.
+     *
+     * @param moduleName - Dotted module path (e.g. 'myapp.models')
+     * @param alias - Optional alias for the import (defaults to the last segment)
+     *
+     * @example
+     * ```typescript
+     * await python.importModule('json')
+     * await python.importModule('myapp.models', 'models')
+     * const result = await python.eval('models.User')
+     * ```
+     */
+    importModule(moduleName: string, alias?: string): Promise<void>;
+    /**
+     * Calls a function by dotted path in the persistent session namespace.
+     *
+     * @param funcPath - Dotted path to the function (e.g. 'json.dumps' or 'my_func')
+     * @param args - Positional arguments
+     * @param kwargs - Keyword arguments
+     * @returns The function's return value
+     *
+     * @example
+     * ```typescript
+     * await python.importModule('json')
+     * const result = await python.call('json.dumps', [{ a: 1 }], { indent: 2 })
+     * ```
+     */
+    call(funcPath: string, args?: any[], kwargs?: Record<string, any>): Promise<any>;
+    /**
+     * Returns all non-dunder variables from the persistent session namespace.
+     *
+     * @returns A record of variable names to their JSON-serializable values
+     *
+     * @example
+     * ```typescript
+     * await python.run('x = 42\ny = "hello"')
+     * const locals = await python.getLocals()
+     * console.log(locals) // { x: 42, y: 'hello' }
+     * ```
+     */
+    getLocals(): Promise<Record<string, any>>;
+    /**
+     * Clears all variables and imports from the persistent session namespace.
+     * The session remains active — you can continue calling run() after reset.
+     *
+     * @example
+     * ```typescript
+     * await python.run('x = 42')
+     * await python.resetSession()
+     * // x is now undefined
+     * ```
+     */
+    resetSession(): Promise<void>;
+}
+export default Python;
+declare module '../feature.js' {
+    interface AvailableFeatures {
+        python: typeof Python;
+    }
+}
+//# sourceMappingURL=python.d.ts.map

package/dist/node/features/python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python.d.ts","sourceRoot":"","sources":["../../../src/node/features/python.ts"],"names":[],"mappings":"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"}