@marktoflow/integrations 2.0.0-alpha.12

package/dist/adapters/codex-workflow.d.ts

@@ -0,0 +1,414 @@
+/**
+ * OpenAI Codex Workflow Actions for marktoflow
+ *
+ * Provides workflow action handlers that expose the full Codex SDK
+ * capabilities to markdown workflows, including:
+ * - Code generation and modification
+ * - Web search and research
+ * - Command execution
+ * - Structured output
+ * - Thread management (resume conversations)
+ */
+import { z } from 'zod';
+import { CodexClient, type CodexClientOptions } from './codex.js';
+import type { CodexResult, CodexThreadOptions, CodexTurnOptions, Input } from './codex-types.js';
+/**
+ * Schema for codex.chat action
+ */
+export declare const CodexChatSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["minimal", "low", "medium", "high", "xhigh"]>>;
+    sandboxMode: z.ZodOptional<z.ZodEnum<["read-only", "workspace-write", "danger-full-access"]>>;
+    webSearch: z.ZodOptional<z.ZodBoolean>;
+    threadId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    threadId?: string | undefined;
+    sandboxMode?: "workspace-write" | "read-only" | "danger-full-access" | undefined;
+    model?: string | undefined;
+    workingDirectory?: string | undefined;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+    webSearch?: boolean | undefined;
+}, {
+    prompt: string;
+    threadId?: string | undefined;
+    sandboxMode?: "workspace-write" | "read-only" | "danger-full-access" | undefined;
+    model?: string | undefined;
+    workingDirectory?: string | undefined;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+    webSearch?: boolean | undefined;
+}>;
+/**
+ * Schema for codex.codeModify action
+ */
+export declare const CodexCodeModifySchema: z.ZodObject<{
+    prompt: z.ZodString;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludeFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<["minimal", "low", "medium", "high", "xhigh"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    additionalDirectories?: string[] | undefined;
+    excludeFiles?: string[] | undefined;
+    workingDirectory?: string | undefined;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+}, {
+    prompt: string;
+    additionalDirectories?: string[] | undefined;
+    excludeFiles?: string[] | undefined;
+    workingDirectory?: string | undefined;
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | undefined;
+}>;
+/**
+ * Schema for codex.codeAnalyze action
+ */
+export declare const CodexCodeAnalyzeSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    excludeFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    additionalDirectories?: string[] | undefined;
+    excludeFiles?: string[] | undefined;
+    workingDirectory?: string | undefined;
+}, {
+    prompt: string;
+    additionalDirectories?: string[] | undefined;
+    excludeFiles?: string[] | undefined;
+    workingDirectory?: string | undefined;
+}>;
+/**
+ * Schema for codex.codeReview action
+ */
+export declare const CodexCodeReviewSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    focusAreas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    workingDirectory?: string | undefined;
+    files?: string[] | undefined;
+    focusAreas?: string[] | undefined;
+}, {
+    prompt: string;
+    workingDirectory?: string | undefined;
+    files?: string[] | undefined;
+    focusAreas?: string[] | undefined;
+}>;
+/**
+ * Schema for codex.webSearch action
+ */
+export declare const CodexWebSearchSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    searchMode: z.ZodOptional<z.ZodEnum<["cached", "live"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    searchMode?: "cached" | "live" | undefined;
+}, {
+    prompt: string;
+    searchMode?: "cached" | "live" | undefined;
+}>;
+/**
+ * Schema for codex.execute action
+ */
+export declare const CodexExecuteSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+    approvalPolicy: z.ZodOptional<z.ZodEnum<["never", "on-request", "on-failure", "untrusted"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    workingDirectory?: string | undefined;
+    approvalPolicy?: "never" | "on-request" | "on-failure" | "untrusted" | undefined;
+}, {
+    prompt: string;
+    workingDirectory?: string | undefined;
+    approvalPolicy?: "never" | "on-request" | "on-failure" | "untrusted" | undefined;
+}>;
+/**
+ * Schema for codex.structured action
+ */
+export declare const CodexStructuredSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    schema: Record<string, unknown>;
+    workingDirectory?: string | undefined;
+}, {
+    prompt: string;
+    schema: Record<string, unknown>;
+    workingDirectory?: string | undefined;
+}>;
+/**
+ * Schema for codex.resume action
+ */
+export declare const CodexResumeSchema: z.ZodObject<{
+    threadId: z.ZodString;
+    prompt: z.ZodString;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    threadId: string;
+    prompt: string;
+    workingDirectory?: string | undefined;
+}, {
+    threadId: string;
+    prompt: string;
+    workingDirectory?: string | undefined;
+}>;
+/**
+ * Schema for codex.withImages action
+ */
+export declare const CodexWithImagesSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    images: z.ZodArray<z.ZodString, "many">;
+    workingDirectory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    images: string[];
+    workingDirectory?: string | undefined;
+}, {
+    prompt: string;
+    images: string[];
+    workingDirectory?: string | undefined;
+}>;
+export type CodexChatInput = z.infer<typeof CodexChatSchema>;
+export type CodexCodeModifyInput = z.infer<typeof CodexCodeModifySchema>;
+export type CodexCodeAnalyzeInput = z.infer<typeof CodexCodeAnalyzeSchema>;
+export type CodexCodeReviewInput = z.infer<typeof CodexCodeReviewSchema>;
+export type CodexWebSearchInput = z.infer<typeof CodexWebSearchSchema>;
+export type CodexExecuteInput = z.infer<typeof CodexExecuteSchema>;
+export type CodexStructuredInput = z.infer<typeof CodexStructuredSchema>;
+export type CodexResumeInput = z.infer<typeof CodexResumeSchema>;
+export type CodexWithImagesInput = z.infer<typeof CodexWithImagesSchema>;
+/**
+ * Create workflow-compatible Codex action handlers
+ *
+ * Returns an object with methods that can be called from workflow actions:
+ * - codex.chat
+ * - codex.codeModify
+ * - codex.codeAnalyze
+ * - codex.codeReview
+ * - codex.webSearch
+ * - codex.execute
+ * - codex.structured
+ * - codex.resume
+ * - codex.withImages
+ */
+export declare function createCodexActions(clientConfig?: CodexClientOptions): {
+    /**
+     * Send a chat message to Codex
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.chat
+     * inputs:
+     *   prompt: "Explain how this codebase works"
+     *   workingDirectory: ./src
+     *   reasoningEffort: medium
+     * ```
+     */
+    chat(inputs: CodexChatInput): Promise<CodexResult>;
+    /**
+     * Modify code with Codex assistance
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.codeModify
+     * inputs:
+     *   prompt: "Add TypeScript types to all functions"
+     *   workingDirectory: ./src
+     *   reasoningEffort: high
+     * ```
+     */
+    codeModify(inputs: CodexCodeModifyInput): Promise<CodexResult>;
+    /**
+     * Analyze code without making changes
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.codeAnalyze
+     * inputs:
+     *   prompt: "Explain the architecture of this project"
+     *   workingDirectory: ./
+     * ```
+     */
+    codeAnalyze(inputs: CodexCodeAnalyzeInput): Promise<CodexResult>;
+    /**
+     * Perform a code review
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.codeReview
+     * inputs:
+     *   prompt: "Review for security issues"
+     *   files:
+     *     - src/auth.ts
+     *     - src/api.ts
+     *   focusAreas: [security, performance]
+     * ```
+     */
+    codeReview(inputs: CodexCodeReviewInput): Promise<CodexResult>;
+    /**
+     * Perform web research
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.webSearch
+     * inputs:
+     *   prompt: "Find best practices for React hooks"
+     *   searchMode: live
+     * ```
+     */
+    webSearch(inputs: CodexWebSearchInput): Promise<CodexResult>;
+    /**
+     * Execute commands via the agent
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.execute
+     * inputs:
+     *   prompt: "Run the test suite and fix any failing tests"
+     *   workingDirectory: ./
+     *   approvalPolicy: never
+     * ```
+     */
+    execute(inputs: CodexExecuteInput): Promise<CodexResult>;
+    /**
+     * Get structured JSON output
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.structured
+     * inputs:
+     *   prompt: "List all exported functions in this file"
+     *   schema:
+     *     type: object
+     *     properties:
+     *       functions:
+     *         type: array
+     *         items:
+     *           type: object
+     *           properties:
+     *             name: { type: string }
+     *             parameters: { type: array, items: { type: string } }
+     *             returnType: { type: string }
+     * ```
+     */
+    structured<T = unknown>(inputs: CodexStructuredInput): Promise<T>;
+    /**
+     * Resume a previous thread
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.resume
+     * inputs:
+     *   threadId: "{{ previous_result.threadId }}"
+     *   prompt: "Now add unit tests for those functions"
+     * ```
+     */
+    resume(inputs: CodexResumeInput): Promise<CodexResult>;
+    /**
+     * Send with local images
+     *
+     * Usage in workflow:
+     * ```yaml
+     * action: codex.withImages
+     * inputs:
+     *   prompt: "Implement this UI based on the mockup"
+     *   images:
+     *     - ./mockups/dashboard.png
+     *     - ./mockups/sidebar.png
+     * ```
+     */
+    withImages(inputs: CodexWithImagesInput): Promise<CodexResult>;
+    /**
+     * Stream a response (for use in handlers that support streaming)
+     *
+     * Usage programmatically:
+     * ```typescript
+     * const actions = createCodexActions();
+     * await actions.stream({
+     *   prompt: "Explain this code",
+     *   onChunk: (chunk) => console.log(chunk),
+     * });
+     * ```
+     */
+    stream(inputs: {
+        prompt: string | Input;
+        threadOptions?: CodexThreadOptions;
+        turnOptions?: CodexTurnOptions;
+        onChunk?: (chunk: string) => void;
+    }): Promise<CodexResult>;
+    /**
+     * Get the last thread ID (for resuming later)
+     */
+    getLastThreadId(): string | null;
+    /**
+     * Get the underlying client for advanced use
+     */
+    getClient(): CodexClient;
+};
+/**
+ * Preset thread configurations for common tasks
+ */
+export declare const CodexPresetConfigs: {
+    /**
+     * Read-only analysis - safe for reviewing code
+     */
+    readOnly: {
+        sandboxMode: "read-only";
+        skipGitRepoCheck: boolean;
+        modelReasoningEffort: "medium";
+    };
+    /**
+     * Code modification - can write to workspace
+     */
+    codeModification: {
+        sandboxMode: "workspace-write";
+        skipGitRepoCheck: boolean;
+        modelReasoningEffort: "high";
+    };
+    /**
+     * Full access - can execute commands
+     */
+    fullAccess: {
+        sandboxMode: "danger-full-access";
+        skipGitRepoCheck: boolean;
+        approvalPolicy: "never";
+        networkAccessEnabled: boolean;
+    };
+    /**
+     * Research mode - web search enabled
+     */
+    research: {
+        webSearchMode: "live";
+        networkAccessEnabled: boolean;
+        skipGitRepoCheck: boolean;
+        sandboxMode: "read-only";
+    };
+    /**
+     * High reasoning - for complex tasks
+     */
+    highReasoning: {
+        modelReasoningEffort: "xhigh";
+        skipGitRepoCheck: boolean;
+        sandboxMode: "workspace-write";
+    };
+};
+/**
+ * Preset prompts for common code review tasks
+ */
+export declare const CodexReviewPrompts: {
+    security: string;
+    performance: string;
+    quality: string;
+    typescript: string;
+};
+export type CodexActions = ReturnType<typeof createCodexActions>;
+//# sourceMappingURL=codex-workflow.d.ts.map

package/dist/adapters/codex-workflow.d.ts.map

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