@moxxy/cli 0.0.12 → 0.1.1

package/dist/chunk-J33O35WX.mjs

@@ -1,532 +0,0 @@
-// ../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"),
-  /** Skip all permission checks — required for --print mode tool execution */
-  dangerouslySkipPermissions: z10.boolean().default(false)
-});
-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
-};