@moxxy/agent-cli 0.0.2 → 0.0.4

package/dist/cli-7CFDLTKN.mjs

@@ -0,0 +1,6 @@
+import {
+  createProgram
+} from "./chunk-HMEDKSSW.mjs";
+export {
+  createProgram
+};

package/dist/cli-T3ZFKHEG.mjs

@@ -0,0 +1,6 @@
+import {
+  createProgram
+} from "./chunk-ZTFAXFQJ.mjs";
+export {
+  createProgram
+};

package/dist/index.js

@@ -1650,6 +1650,538 @@ var init_pr = __esm({
   }
 });
 
+// ../types/dist/index.mjs
+var import_zod, import_zod2, import_zod3, import_zod4, import_zod5, import_zod6, import_zod7, import_zod8, import_zod9, import_zod10, import_zod11, uuidSchema, timestampSchema, paginationSchema, activityTypeSchema, taskActivitySchema, createActivitySchema, agentStatusSchema, agentTypeSchema, agentCapabilitySchema, agentIdentitySchema, agentModelConfigSchema, agentSchema, createAgentSchema, updateAgentSchema, taskFiltersSchema, INTEGRATION_TYPES, NOTIFICATION_EVENTS, createIntegrationSchema, updateIntegrationSchema, projectStatusSchema, workflowModeSchema, validationSettingsSchema, workflowSettingsSchema, prdStatusSchema, prdTemplateSchema, prdTaskSchema, projectSchema, generatePRDInputSchema, importPRDTasksInputSchema, updatePRDInputSchema, createProjectSchema, updateProjectSchema, taskStatusSchema, taskTypeSchema, taskPrioritySchema, agentNoteTypeSchema, agentNoteSchema, taskSchema, createTaskSchema, updateTaskSchema, clientEventTypeSchema, serverEventTypeSchema, githubIssuePayloadSchema, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_COMPLEXITIES, issueClassificationSchema, PIPELINE_STAGES, PIPELINE_STATUSES, pipelineStageResultSchema, pipelineRunSchema, gatewayConfigSchema, githubAuthConfigSchema, webhookServerConfigSchema, watchedRepoSchema, agentRunConfigSchema, sdkProviderSchema, claudeConfigSchema, pipelineConfigSchema, moxxyConfigSchema, agentCommandResultSchema, argDefSchema, optionDefSchema, agentCLICommandDefSchema, workflowStepSchema, workflowSchema, workflowStepResultSchema, workflowResultSchema;
+var init_dist = __esm({
+  "../types/dist/index.mjs"() {
+    "use strict";
+    import_zod = require("zod");
+    import_zod2 = require("zod");
+    import_zod3 = require("zod");
+    import_zod4 = require("zod");
+    import_zod5 = require("zod");
+    import_zod6 = require("zod");
+    import_zod7 = require("zod");
+    import_zod8 = require("zod");
+    import_zod9 = require("zod");
+    import_zod10 = require("zod");
+    import_zod11 = require("zod");
+    uuidSchema = import_zod2.z.string().uuid();
+    timestampSchema = import_zod2.z.number().int().positive();
+    paginationSchema = import_zod2.z.object({
+      page: import_zod2.z.number().int().positive().optional().default(1),
+      limit: import_zod2.z.number().int().positive().max(100).optional().default(20),
+      orderBy: import_zod2.z.string().optional(),
+      order: import_zod2.z.enum(["asc", "desc"]).optional().default("desc")
+    });
+    activityTypeSchema = import_zod.z.enum([
+      "created",
+      "assigned",
+      "status_change",
+      "comment",
+      "commit",
+      "pr_created",
+      "pr_merged",
+      "pr_closed"
+    ]);
+    taskActivitySchema = import_zod.z.object({
+      id: uuidSchema,
+      taskId: uuidSchema,
+      agentId: uuidSchema.nullable(),
+      activityType: activityTypeSchema,
+      description: import_zod.z.string().max(500),
+      metadata: import_zod.z.record(import_zod.z.any()),
+      createdAt: timestampSchema
+    });
+    createActivitySchema = import_zod.z.object({
+      taskId: uuidSchema,
+      agentId: uuidSchema.nullable().optional(),
+      activityType: activityTypeSchema,
+      description: import_zod.z.string().max(500),
+      metadata: import_zod.z.record(import_zod.z.any()).optional().default({})
+    });
+    agentStatusSchema = import_zod3.z.enum(["available", "busy", "offline"]);
+    agentTypeSchema = import_zod3.z.enum([
+      "developer",
+      "prd",
+      "code-review",
+      "orchestrator",
+      "custom"
+    ]);
+    agentCapabilitySchema = import_zod3.z.enum([
+      "frontend",
+      "backend",
+      "fullstack",
+      "devops",
+      "testing",
+      "documentation"
+    ]);
+    agentIdentitySchema = import_zod3.z.object({
+      /** Display name for the agent (persona name) */
+      displayName: import_zod3.z.string().max(100).optional(),
+      /** Theme/persona description */
+      theme: import_zod3.z.string().max(500).optional(),
+      /** Emoji representation */
+      emoji: import_zod3.z.string().max(10).optional(),
+      /** Avatar path or URL */
+      avatar: import_zod3.z.string().url().optional().or(import_zod3.z.string().max(0)),
+      /** Custom system prompt */
+      systemPrompt: import_zod3.z.string().max(1e4).optional()
+    });
+    agentModelConfigSchema = import_zod3.z.object({
+      /** Primary model (provider/model format) */
+      primary: import_zod3.z.string().optional(),
+      /** Fallback models in order of preference */
+      fallbacks: import_zod3.z.array(import_zod3.z.string()).optional()
+    });
+    agentSchema = import_zod3.z.object({
+      id: uuidSchema,
+      name: import_zod3.z.string().min(1).max(100),
+      moltAgentId: import_zod3.z.string().min(1),
+      githubToken: import_zod3.z.string().min(1),
+      githubUsername: import_zod3.z.string().min(1),
+      workspace: import_zod3.z.string().min(1),
+      capabilities: import_zod3.z.array(agentCapabilitySchema),
+      status: agentStatusSchema,
+      currentTaskId: uuidSchema.nullable(),
+      agentType: agentTypeSchema.optional(),
+      identity: agentIdentitySchema.optional(),
+      modelConfig: agentModelConfigSchema.optional(),
+      projectId: uuidSchema.optional(),
+      lastSyncAt: timestampSchema,
+      createdAt: timestampSchema,
+      updatedAt: timestampSchema
+    });
+    createAgentSchema = import_zod3.z.object({
+      name: import_zod3.z.string().min(1).max(100),
+      githubToken: import_zod3.z.string().min(1),
+      githubUsername: import_zod3.z.string().min(1),
+      capabilities: import_zod3.z.array(agentCapabilitySchema).min(1),
+      workspace: import_zod3.z.string().min(1),
+      /** Agent type for specialized behaviors */
+      agentType: agentTypeSchema.optional(),
+      /** Agent identity/persona configuration */
+      identity: agentIdentitySchema.optional()
+    });
+    updateAgentSchema = import_zod3.z.object({
+      name: import_zod3.z.string().min(1).max(100).optional(),
+      status: agentStatusSchema.optional(),
+      workspace: import_zod3.z.string().min(1).optional(),
+      capabilities: import_zod3.z.array(agentCapabilitySchema).optional(),
+      /** Agent type for specialized behaviors */
+      agentType: agentTypeSchema.optional(),
+      /** Agent identity/persona configuration */
+      identity: agentIdentitySchema.optional(),
+      /** Model configuration update */
+      modelConfig: agentModelConfigSchema.optional(),
+      /** Update GitHub PAT token */
+      githubToken: import_zod3.z.string().min(1).optional(),
+      /** Update GitHub username */
+      githubUsername: import_zod3.z.string().min(1).optional()
+    });
+    taskFiltersSchema = import_zod4.z.object({
+      projectId: import_zod4.z.string().uuid().optional(),
+      status: import_zod4.z.string().optional(),
+      type: import_zod4.z.string().optional(),
+      priority: import_zod4.z.string().optional(),
+      assignedAgentId: import_zod4.z.string().uuid().optional()
+    });
+    INTEGRATION_TYPES = ["slack", "discord", "email", "github"];
+    NOTIFICATION_EVENTS = [
+      "task:created",
+      "task:completed",
+      "task:failed",
+      "task:assigned",
+      "task:status_changed",
+      "agent:status_changed",
+      "pr:created",
+      "pr:merged"
+    ];
+    createIntegrationSchema = import_zod5.z.object({
+      type: import_zod5.z.enum(INTEGRATION_TYPES),
+      name: import_zod5.z.string().min(1).max(100),
+      enabled: import_zod5.z.boolean().optional().default(false),
+      config: import_zod5.z.record(import_zod5.z.unknown()),
+      enabledEvents: import_zod5.z.array(import_zod5.z.enum(NOTIFICATION_EVENTS)).optional().default([])
+    });
+    updateIntegrationSchema = import_zod5.z.object({
+      name: import_zod5.z.string().min(1).max(100).optional(),
+      enabled: import_zod5.z.boolean().optional(),
+      config: import_zod5.z.record(import_zod5.z.unknown()).optional(),
+      enabledEvents: import_zod5.z.array(import_zod5.z.enum(NOTIFICATION_EVENTS)).optional()
+    });
+    projectStatusSchema = import_zod6.z.enum(["active", "archived", "paused"]);
+    workflowModeSchema = import_zod6.z.enum(["manual", "automatic"]);
+    validationSettingsSchema = import_zod6.z.object({
+      runInstall: import_zod6.z.boolean().optional(),
+      runTests: import_zod6.z.boolean().optional(),
+      runBuild: import_zod6.z.boolean().optional(),
+      runLint: import_zod6.z.boolean().optional(),
+      blockOnFailure: import_zod6.z.boolean().optional(),
+      installCommand: import_zod6.z.string().max(500).optional(),
+      testCommand: import_zod6.z.string().max(500).optional(),
+      buildCommand: import_zod6.z.string().max(500).optional(),
+      lintCommand: import_zod6.z.string().max(500).optional(),
+      maxRetries: import_zod6.z.number().int().min(0).max(100).optional(),
+      preferSameAgent: import_zod6.z.boolean().optional(),
+      timeout: import_zod6.z.number().int().min(1e3).max(36e5).optional()
+      // 1s to 1h
+    });
+    workflowSettingsSchema = import_zod6.z.object({
+      mode: workflowModeSchema,
+      previewBranch: import_zod6.z.string().min(1).max(100),
+      autoMerge: import_zod6.z.boolean().optional(),
+      validation: validationSettingsSchema.optional()
+    });
+    prdStatusSchema = import_zod6.z.enum([
+      "idle",
+      "generating",
+      "completed",
+      "failed",
+      "tasks_generating",
+      "tasks_completed",
+      "tasks_failed"
+    ]);
+    prdTemplateSchema = import_zod6.z.enum(["mobile", "web", "api", "feature", "data-pipeline"]);
+    prdTaskSchema = import_zod6.z.object({
+      id: import_zod6.z.string(),
+      prdId: import_zod6.z.string(),
+      step: import_zod6.z.number(),
+      title: import_zod6.z.string(),
+      description: import_zod6.z.string(),
+      status: import_zod6.z.enum(["todo", "in_progress", "done", "blocked"]),
+      priority: import_zod6.z.enum(["P0", "P1", "P2"]),
+      estimatedHours: import_zod6.z.number().optional(),
+      phase: import_zod6.z.enum(["discovery", "design", "development", "testing", "deployment"]).optional(),
+      createdAt: import_zod6.z.string(),
+      updatedAt: import_zod6.z.string(),
+      completedAt: import_zod6.z.string().optional()
+    });
+    projectSchema = import_zod6.z.object({
+      id: uuidSchema,
+      name: import_zod6.z.string().min(1).max(100),
+      description: import_zod6.z.string().max(500),
+      githubRepoUrl: import_zod6.z.string().url(),
+      githubOwner: import_zod6.z.string().min(1),
+      githubRepo: import_zod6.z.string().min(1),
+      status: projectStatusSchema,
+      defaultBranch: import_zod6.z.string().min(1).max(100).optional(),
+      workflowSettings: workflowSettingsSchema.optional(),
+      assignedAgentIds: import_zod6.z.array(uuidSchema).optional(),
+      prd: import_zod6.z.string().optional(),
+      prdGeneratedAt: timestampSchema.optional(),
+      prdStatus: prdStatusSchema.optional(),
+      prdError: import_zod6.z.string().optional(),
+      prdTemplate: prdTemplateSchema.optional(),
+      prdTasks: import_zod6.z.array(prdTaskSchema).optional(),
+      createdAt: timestampSchema,
+      updatedAt: timestampSchema
+    });
+    generatePRDInputSchema = import_zod6.z.object({
+      template: prdTemplateSchema.optional().default("feature")
+    });
+    importPRDTasksInputSchema = import_zod6.z.object({
+      tasks: import_zod6.z.array(
+        import_zod6.z.object({
+          title: import_zod6.z.string(),
+          description: import_zod6.z.string(),
+          priority: import_zod6.z.enum(["P0", "P1", "P2"]).optional(),
+          estimatedHours: import_zod6.z.number().optional(),
+          phase: import_zod6.z.string().optional()
+        })
+      ),
+      taskType: import_zod6.z.enum(["feature", "bug", "research", "refactor", "documentation"])
+    });
+    updatePRDInputSchema = import_zod6.z.object({
+      prd: import_zod6.z.string()
+    });
+    createProjectSchema = import_zod6.z.object({
+      name: import_zod6.z.string().min(1).max(100),
+      description: import_zod6.z.string().max(500),
+      githubRepoUrl: import_zod6.z.string().url()
+    });
+    updateProjectSchema = import_zod6.z.object({
+      name: import_zod6.z.string().min(1).max(100).optional(),
+      description: import_zod6.z.string().max(500).optional(),
+      status: projectStatusSchema.optional(),
+      defaultBranch: import_zod6.z.string().min(1).max(100).optional(),
+      workflowSettings: workflowSettingsSchema.optional()
+    });
+    taskStatusSchema = import_zod7.z.enum(["todo", "in_progress", "review", "done", "blocked"]);
+    taskTypeSchema = import_zod7.z.enum(["feature", "bug", "research", "refactor", "documentation"]);
+    taskPrioritySchema = import_zod7.z.enum(["low", "medium", "high", "urgent"]);
+    agentNoteTypeSchema = import_zod7.z.enum([
+      "progress",
+      "summary",
+      "error",
+      "completion",
+      "feedback"
+    ]);
+    agentNoteSchema = import_zod7.z.object({
+      id: uuidSchema,
+      agentId: uuidSchema,
+      agentName: import_zod7.z.string(),
+      content: import_zod7.z.string(),
+      type: agentNoteTypeSchema,
+      createdAt: timestampSchema,
+      isUserFeedback: import_zod7.z.boolean().optional()
+    });
+    taskSchema = import_zod7.z.object({
+      id: uuidSchema,
+      projectId: uuidSchema,
+      title: import_zod7.z.string().min(1).max(200),
+      description: import_zod7.z.string().max(2e3),
+      type: taskTypeSchema,
+      status: taskStatusSchema,
+      priority: taskPrioritySchema,
+      position: import_zod7.z.number().int().default(0),
+      // Manual ordering within status
+      assignedAgentId: uuidSchema.nullable(),
+      autoAssign: import_zod7.z.boolean().default(true),
+      // Whether agents should auto-pick this task
+      agentNotes: import_zod7.z.array(agentNoteSchema).default([]),
+      githubIssueNumber: import_zod7.z.number().int().positive().nullable(),
+      githubPrNumber: import_zod7.z.number().int().positive().nullable(),
+      metadata: import_zod7.z.record(import_zod7.z.any()),
+      blockedBy: import_zod7.z.array(uuidSchema).default([]),
+      // Task IDs that must be completed before this task
+      blocking: import_zod7.z.array(uuidSchema).default([]),
+      // Task IDs that depend on this task
+      createdAt: timestampSchema,
+      updatedAt: timestampSchema,
+      completedAt: timestampSchema.nullable()
+    });
+    createTaskSchema = import_zod7.z.object({
+      projectId: uuidSchema,
+      title: import_zod7.z.string().min(1).max(200),
+      description: import_zod7.z.string().max(2e3),
+      type: taskTypeSchema,
+      priority: taskPrioritySchema.optional().default("medium"),
+      assignedAgentId: uuidSchema.optional(),
+      // Optional agent to assign on creation
+      autoAssign: import_zod7.z.boolean().optional().default(true),
+      // Auto-assign to agents (default: true)
+      blockedBy: import_zod7.z.array(uuidSchema).optional()
+      // Task IDs that must be completed before this task
+    });
+    updateTaskSchema = import_zod7.z.object({
+      title: import_zod7.z.string().min(1).max(200).optional(),
+      description: import_zod7.z.string().max(2e3).optional(),
+      type: taskTypeSchema.optional(),
+      status: taskStatusSchema.optional(),
+      priority: taskPrioritySchema.optional(),
+      position: import_zod7.z.number().int().optional(),
+      // Manual ordering within status
+      assignedAgentId: uuidSchema.nullable().optional(),
+      autoAssign: import_zod7.z.boolean().optional(),
+      // Whether agents should auto-pick this task
+      githubIssueNumber: import_zod7.z.number().int().positive().nullable().optional(),
+      githubPrNumber: import_zod7.z.number().int().positive().nullable().optional(),
+      metadata: import_zod7.z.record(import_zod7.z.any()).optional(),
+      blockedBy: import_zod7.z.array(uuidSchema).optional()
+      // Task IDs that must be completed before this task
+    });
+    clientEventTypeSchema = import_zod8.z.enum([
+      "subscribe:project",
+      "unsubscribe:project",
+      "subscribe:task",
+      "unsubscribe:task"
+    ]);
+    serverEventTypeSchema = import_zod8.z.enum([
+      "task:created",
+      "task:updated",
+      "task:status_changed",
+      "task:assigned",
+      "task:progress",
+      "task:stream",
+      "task:note_added",
+      "task:execution_cancelled",
+      "task:dependencies_updated",
+      "tasks:reordered",
+      "agent:created",
+      "agent:updated",
+      "agent:status_changed",
+      "agent:log",
+      "activity:created",
+      "project:updated",
+      "project:prd_status_changed",
+      "error"
+    ]);
+    githubIssuePayloadSchema = import_zod10.z.object({
+      action: import_zod10.z.string(),
+      issueNumber: import_zod10.z.number().int().positive(),
+      title: import_zod10.z.string(),
+      body: import_zod10.z.string().nullable(),
+      labels: import_zod10.z.array(import_zod10.z.string()),
+      author: import_zod10.z.string(),
+      repo: import_zod10.z.object({
+        owner: import_zod10.z.string(),
+        name: import_zod10.z.string(),
+        fullName: import_zod10.z.string(),
+        defaultBranch: import_zod10.z.string(),
+        cloneUrl: import_zod10.z.string()
+      }),
+      url: import_zod10.z.string().url(),
+      createdAt: import_zod10.z.string()
+    });
+    ISSUE_TYPES = ["feature", "bug", "refactor", "docs", "test", "chore"];
+    ISSUE_PRIORITIES = ["low", "medium", "high", "urgent"];
+    ISSUE_COMPLEXITIES = ["trivial", "small", "medium", "large", "epic"];
+    issueClassificationSchema = import_zod10.z.object({
+      type: import_zod10.z.enum(ISSUE_TYPES),
+      priority: import_zod10.z.enum(ISSUE_PRIORITIES),
+      complexity: import_zod10.z.enum(ISSUE_COMPLEXITIES),
+      confidence: import_zod10.z.number().min(0).max(1),
+      reasoning: import_zod10.z.string()
+    });
+    PIPELINE_STAGES = [
+      "triage",
+      "research",
+      "inspect",
+      "plan",
+      "implement"
+    ];
+    PIPELINE_STATUSES = [
+      "pending",
+      "running",
+      "completed",
+      "failed",
+      "cancelled"
+    ];
+    pipelineStageResultSchema = import_zod10.z.object({
+      stage: import_zod10.z.enum(PIPELINE_STAGES),
+      status: import_zod10.z.enum(PIPELINE_STATUSES),
+      output: import_zod10.z.unknown().optional(),
+      error: import_zod10.z.string().optional(),
+      duration_ms: import_zod10.z.number().optional()
+    });
+    pipelineRunSchema = import_zod10.z.object({
+      id: import_zod10.z.string(),
+      issueNumber: import_zod10.z.number().int().positive(),
+      repo: import_zod10.z.object({
+        owner: import_zod10.z.string(),
+        name: import_zod10.z.string()
+      }),
+      stages: import_zod10.z.array(pipelineStageResultSchema),
+      status: import_zod10.z.enum(PIPELINE_STATUSES),
+      branchName: import_zod10.z.string().optional(),
+      prNumber: import_zod10.z.number().int().positive().optional(),
+      classification: issueClassificationSchema.optional(),
+      createdAt: import_zod10.z.number(),
+      updatedAt: import_zod10.z.number()
+    });
+    gatewayConfigSchema = import_zod9.z.object({
+      url: import_zod9.z.string().url(),
+      authToken: import_zod9.z.string().optional(),
+      deviceId: import_zod9.z.string().optional(),
+      devicePrivateKey: import_zod9.z.string().optional()
+    });
+    githubAuthConfigSchema = import_zod9.z.object({
+      token: import_zod9.z.string(),
+      webhookSecret: import_zod9.z.string().optional(),
+      appId: import_zod9.z.string().optional(),
+      privateKey: import_zod9.z.string().optional()
+    });
+    webhookServerConfigSchema = import_zod9.z.object({
+      port: import_zod9.z.number().int().positive().default(3456),
+      host: import_zod9.z.string().default("0.0.0.0"),
+      path: import_zod9.z.string().default("/webhook/github")
+    });
+    watchedRepoSchema = import_zod9.z.object({
+      owner: import_zod9.z.string(),
+      repo: import_zod9.z.string(),
+      defaultBranch: import_zod9.z.string().default("main"),
+      enabledEvents: import_zod9.z.array(import_zod9.z.string()).default(["issues.opened", "issues.labeled"]),
+      labels: import_zod9.z.array(import_zod9.z.string()).optional()
+    });
+    agentRunConfigSchema = import_zod9.z.object({
+      moltAgentId: import_zod9.z.string().optional(),
+      maxConcurrentTasks: import_zod9.z.number().int().positive().default(1)
+    });
+    sdkProviderSchema = import_zod9.z.enum(["molt", "claude"]).default("molt");
+    claudeConfigSchema = import_zod9.z.object({
+      apiKey: import_zod9.z.string().optional(),
+      cliPath: import_zod9.z.string().default("claude"),
+      model: import_zod9.z.string().default("claude-sonnet-4-5"),
+      timeout: import_zod9.z.number().int().positive().default(3e5),
+      permissionMode: import_zod9.z.string().default("default")
+    });
+    pipelineConfigSchema = import_zod9.z.object({
+      enabledStages: import_zod9.z.array(import_zod9.z.enum(PIPELINE_STAGES)).default(["triage", "research", "inspect", "plan", "implement"])
+    });
+    moxxyConfigSchema = import_zod9.z.object({
+      version: import_zod9.z.number().int().positive().default(1),
+      sdk: sdkProviderSchema,
+      gateway: gatewayConfigSchema.optional(),
+      github: githubAuthConfigSchema,
+      webhook: webhookServerConfigSchema.optional(),
+      repos: import_zod9.z.array(watchedRepoSchema).default([]),
+      agent: agentRunConfigSchema.optional(),
+      pipeline: pipelineConfigSchema.optional(),
+      claude: claudeConfigSchema.optional()
+    });
+    agentCommandResultSchema = import_zod11.z.object({
+      success: import_zod11.z.boolean(),
+      command: import_zod11.z.string(),
+      data: import_zod11.z.unknown().optional(),
+      error: import_zod11.z.object({
+        code: import_zod11.z.string(),
+        message: import_zod11.z.string(),
+        details: import_zod11.z.string().optional()
+      }).optional(),
+      duration_ms: import_zod11.z.number()
+    });
+    argDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      required: import_zod11.z.boolean().default(false),
+      type: import_zod11.z.enum(["string", "number", "boolean"]).default("string")
+    });
+    optionDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      short: import_zod11.z.string().optional(),
+      description: import_zod11.z.string(),
+      required: import_zod11.z.boolean().default(false),
+      type: import_zod11.z.enum(["string", "number", "boolean"]).default("string"),
+      defaultValue: import_zod11.z.unknown().optional()
+    });
+    agentCLICommandDefSchema = import_zod11.z.object({
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      args: import_zod11.z.array(argDefSchema),
+      options: import_zod11.z.array(optionDefSchema),
+      examples: import_zod11.z.array(import_zod11.z.string())
+    });
+    workflowStepSchema = import_zod11.z.object({
+      id: import_zod11.z.string(),
+      plugin: import_zod11.z.string(),
+      command: import_zod11.z.string(),
+      args: import_zod11.z.record(import_zod11.z.unknown()),
+      description: import_zod11.z.string(),
+      dependsOn: import_zod11.z.array(import_zod11.z.string()).optional(),
+      optional: import_zod11.z.boolean().optional()
+    });
+    workflowSchema = import_zod11.z.object({
+      id: import_zod11.z.string(),
+      name: import_zod11.z.string(),
+      description: import_zod11.z.string(),
+      steps: import_zod11.z.array(workflowStepSchema),
+      context: import_zod11.z.record(import_zod11.z.unknown())
+    });
+    workflowStepResultSchema = import_zod11.z.object({
+      stepId: import_zod11.z.string(),
+      result: agentCommandResultSchema,
+      skipped: import_zod11.z.boolean().default(false)
+    });
+    workflowResultSchema = import_zod11.z.object({
+      workflowId: import_zod11.z.string(),
+      success: import_zod11.z.boolean(),
+      stepResults: import_zod11.z.array(workflowStepResultSchema),
+      duration_ms: import_zod11.z.number()
+    });
+  }
+});
+
 // src/plugins/workflow/run.ts
 async function executeStep(step, cwd) {
   const args = [step.plugin, step.command];
@@ -1708,7 +2240,7 @@ function registerRun(parent) {
         return;
       }
       const raw = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
-      const workflow = import_types.workflowSchema.parse(raw);
+      const workflow = workflowSchema.parse(raw);
       log(`Running workflow: ${workflow.name}`);
       const sortedSteps = topologicalSort(workflow.steps);
       const stepResults = [];
@@ -1794,13 +2326,13 @@ function registerRun(parent) {
     }
   });
 }
-var fs14, path14, import_types;
+var fs14, path14;
 var init_run = __esm({
   "src/plugins/workflow/run.ts"() {
     "use strict";
     fs14 = __toESM(require("fs"));
     path14 = __toESM(require("path"));
-    import_types = require("@moxxy/types");
+    init_dist();
     init_exec();
     init_result();
   }

package/dist/index.mjs

@@ -7,11 +7,11 @@ import {
   log,
   output,
   success
-} from "./chunk-SEOH5HLK.mjs";
+} from "./chunk-ZTFAXFQJ.mjs";
 
 // src/index.ts
 async function run() {
-  const { createProgram: createProgram2 } = await import("./cli-XX4HNXSW.mjs");
+  const { createProgram: createProgram2 } = await import("./cli-T3ZFKHEG.mjs");
   const program = createProgram2();
   await program.parseAsync(process.argv);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moxxy/agent-cli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Agent-facing CLI tool for structured operations",
   "license": "MIT",
   "repository": {
@@ -40,19 +40,19 @@
   "dependencies": {
     "commander": "^13.0.0",
     "glob": "^11.0.0",
-    "zod": "^3.23.8",
-    "@moxxy/types": "1.0.0"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.13",
     "@types/node": "^22.0.0",
     "tsup": "^8.0.1",
     "typescript": "^5.7.0",
-    "vitest": "^2.1.0"
+    "vitest": "^2.1.0",
+    "@moxxy/types": "1.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "biome check .",