@moxxy/cli 0.0.2 → 0.0.4

package/dist/chunk-GSNMMI3H.mjs

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