@moxxy/cli 0.0.2 → 0.0.3

package/dist/chunk-NGVL4Q5C.mjs

@@ -0,0 +1,1102 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/config/config-manager.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// ../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 z9 } from "zod";
+import { z as z10 } 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 gatewayConfigSchema = z9.object({
+  url: z9.string().url(),
+  authToken: z9.string().optional(),
+  deviceId: z9.string().optional(),
+  devicePrivateKey: z9.string().optional()
+});
+var githubAuthConfigSchema = z9.object({
+  token: z9.string(),
+  webhookSecret: z9.string().optional(),
+  appId: z9.string().optional(),
+  privateKey: z9.string().optional()
+});
+var webhookServerConfigSchema = z9.object({
+  port: z9.number().int().positive().default(3456),
+  host: z9.string().default("0.0.0.0"),
+  path: z9.string().default("/webhook/github")
+});
+var watchedRepoSchema = z9.object({
+  owner: z9.string(),
+  repo: z9.string(),
+  defaultBranch: z9.string().default("main"),
+  enabledEvents: z9.array(z9.string()).default(["issues.opened", "issues.labeled"]),
+  labels: z9.array(z9.string()).optional()
+});
+var agentRunConfigSchema = z9.object({
+  moltAgentId: z9.string().optional(),
+  maxConcurrentTasks: z9.number().int().positive().default(1)
+});
+var sdkProviderSchema = z9.enum(["molt", "claude"]).default("molt");
+var claudeConfigSchema = z9.object({
+  apiKey: z9.string().optional(),
+  cliPath: z9.string().default("claude"),
+  model: z9.string().default("claude-sonnet-4-5"),
+  timeout: z9.number().int().positive().default(3e5),
+  permissionMode: z9.string().default("default")
+});
+var moxxyConfigSchema = z9.object({
+  version: z9.number().int().positive().default(1),
+  sdk: sdkProviderSchema,
+  gateway: gatewayConfigSchema.optional(),
+  github: githubAuthConfigSchema,
+  webhook: webhookServerConfigSchema.optional(),
+  repos: z9.array(watchedRepoSchema).default([]),
+  agent: agentRunConfigSchema.optional(),
+  claude: claudeConfigSchema.optional()
+});
+var agentCommandResultSchema = z10.object({
+  success: z10.boolean(),
+  command: z10.string(),
+  data: z10.unknown().optional(),
+  error: z10.object({
+    code: z10.string(),
+    message: z10.string(),
+    details: z10.string().optional()
+  }).optional(),
+  duration_ms: z10.number()
+});
+var argDefSchema = z10.object({
+  name: z10.string(),
+  description: z10.string(),
+  required: z10.boolean().default(false),
+  type: z10.enum(["string", "number", "boolean"]).default("string")
+});
+var optionDefSchema = z10.object({
+  name: z10.string(),
+  short: z10.string().optional(),
+  description: z10.string(),
+  required: z10.boolean().default(false),
+  type: z10.enum(["string", "number", "boolean"]).default("string"),
+  defaultValue: z10.unknown().optional()
+});
+var agentCLICommandDefSchema = z10.object({
+  name: z10.string(),
+  description: z10.string(),
+  args: z10.array(argDefSchema),
+  options: z10.array(optionDefSchema),
+  examples: z10.array(z10.string())
+});
+var workflowStepSchema = z10.object({
+  id: z10.string(),
+  plugin: z10.string(),
+  command: z10.string(),
+  args: z10.record(z10.unknown()),
+  description: z10.string(),
+  dependsOn: z10.array(z10.string()).optional(),
+  optional: z10.boolean().optional()
+});
+var workflowSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  description: z10.string(),
+  steps: z10.array(workflowStepSchema),
+  context: z10.record(z10.unknown())
+});
+var workflowStepResultSchema = z10.object({
+  stepId: z10.string(),
+  result: agentCommandResultSchema,
+  skipped: z10.boolean().default(false)
+});
+var workflowResultSchema = z10.object({
+  workflowId: z10.string(),
+  success: z10.boolean(),
+  stepResults: z10.array(workflowStepResultSchema),
+  duration_ms: z10.number()
+});
+var githubIssuePayloadSchema = z11.object({
+  action: z11.string(),
+  issueNumber: z11.number().int().positive(),
+  title: z11.string(),
+  body: z11.string().nullable(),
+  labels: z11.array(z11.string()),
+  author: z11.string(),
+  repo: z11.object({
+    owner: z11.string(),
+    name: z11.string(),
+    fullName: z11.string(),
+    defaultBranch: z11.string(),
+    cloneUrl: z11.string()
+  }),
+  url: z11.string().url(),
+  createdAt: z11.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 = z11.object({
+  type: z11.enum(ISSUE_TYPES),
+  priority: z11.enum(ISSUE_PRIORITIES),
+  complexity: z11.enum(ISSUE_COMPLEXITIES),
+  confidence: z11.number().min(0).max(1),
+  reasoning: z11.string()
+});
+var PIPELINE_STAGES = [
+  "triage",
+  "research",
+  "inspect",
+  "plan",
+  "implement"
+];
+var PIPELINE_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var pipelineStageResultSchema = z11.object({
+  stage: z11.enum(PIPELINE_STAGES),
+  status: z11.enum(PIPELINE_STATUSES),
+  output: z11.unknown().optional(),
+  error: z11.string().optional(),
+  duration_ms: z11.number().optional()
+});
+var pipelineRunSchema = z11.object({
+  id: z11.string(),
+  issueNumber: z11.number().int().positive(),
+  repo: z11.object({
+    owner: z11.string(),
+    name: z11.string()
+  }),
+  stages: z11.array(pipelineStageResultSchema),
+  status: z11.enum(PIPELINE_STATUSES),
+  branchName: z11.string().optional(),
+  prNumber: z11.number().int().positive().optional(),
+  classification: issueClassificationSchema.optional(),
+  createdAt: z11.number(),
+  updatedAt: z11.number()
+});
+
+// src/config/config-defaults.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  webhook: { port: 3456, host: "0.0.0.0", path: "/webhook/github" },
+  repos: []
+};
+var CONFIG_DIR = ".moxxy";
+var CONFIG_FILE = "config.json";
+
+// src/config/config-manager.ts
+var ConfigManager = class {
+  configPath;
+  config = null;
+  constructor(configDir) {
+    const base = configDir || join(homedir(), CONFIG_DIR);
+    this.configPath = join(base, CONFIG_FILE);
+  }
+  async load() {
+    if (!existsSync(this.configPath)) {
+      throw new Error(`Config not found at ${this.configPath}. Run 'moxxy config init' first.`);
+    }
+    const raw = await readFile(this.configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    this.config = moxxyConfigSchema.parse(parsed);
+    return this.config;
+  }
+  async save(config) {
+    const dir = join(this.configPath, "..");
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    this.config = moxxyConfigSchema.parse(config);
+    await writeFile(this.configPath, JSON.stringify(this.config, null, 2) + "\n");
+  }
+  async init(config) {
+    const merged = { ...DEFAULT_CONFIG, ...config };
+    await this.save(merged);
+    return merged;
+  }
+  getConfig() {
+    if (!this.config) throw new Error("Config not loaded. Call load() first.");
+    return this.config;
+  }
+  async addRepo(repo) {
+    const config = this.getConfig();
+    const exists = config.repos.find((r) => r.owner === repo.owner && r.repo === repo.repo);
+    if (exists) throw new Error(`Repo ${repo.owner}/${repo.repo} already configured.`);
+    config.repos.push(repo);
+    await this.save(config);
+  }
+  async removeRepo(owner, repo) {
+    const config = this.getConfig();
+    config.repos = config.repos.filter((r) => !(r.owner === owner && r.repo === repo));
+    await this.save(config);
+  }
+  async set(key, value) {
+    const config = this.getConfig();
+    const keys = key.split(".");
+    let obj = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      obj = obj[keys[i]] ??= {};
+    }
+    obj[keys[keys.length - 1]] = value;
+    await this.save(config);
+  }
+  get(key) {
+    const config = this.getConfig();
+    const keys = key.split(".");
+    let obj = config;
+    for (const k of keys) {
+      obj = obj?.[k];
+    }
+    return obj;
+  }
+  get path() {
+    return this.configPath;
+  }
+};
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function info(message) {
+  console.log(`${chalk.cyan("i")} ${message}`);
+}
+function success(message) {
+  console.log(`${chalk.green("\u2714")} ${message}`);
+}
+function error(message) {
+  console.error(`${chalk.red("\u2716")} ${message}`);
+}
+function warn(message) {
+  console.warn(`${chalk.yellow("\u26A0")} ${message}`);
+}
+function spinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function printBanner() {
+  console.log();
+  console.log(chalk.bold.cyan("  Moxxy"));
+  console.log(chalk.dim("  Agent orchestration platform"));
+  console.log();
+}
+function section(title) {
+  console.log();
+  console.log(chalk.bold(title));
+  console.log(chalk.dim("\u2500".repeat(title.length)));
+}
+function keyValue(key, value) {
+  console.log(`  ${chalk.dim(key + ":")} ${value}`);
+}
+function listItem(text) {
+  console.log(`  ${chalk.dim("\u2022")} ${text}`);
+}
+
+// src/commands/start.ts
+var SDK_NAMES = {
+  molt: "Molt Gateway",
+  claude: "Claude CLI"
+};
+async function createSDK(config) {
+  const provider = config.sdk || "molt";
+  const sdkName = SDK_NAMES[provider] || provider;
+  if (provider === "claude") {
+    const { ClaudeSDK } = await import("./src-D5HMDDVE.mjs");
+    const claudeConfig = config.claude || {};
+    const sdk2 = await ClaudeSDK.create({
+      cliPath: claudeConfig.cliPath,
+      model: claudeConfig.model,
+      timeout: claudeConfig.timeout,
+      permissionMode: claudeConfig.permissionMode
+    });
+    return { sdk: sdk2, sdkName };
+  }
+  if (!config.gateway) {
+    throw new Error('Gateway configuration is required for the molt SDK. Run "moxxy config init --sdk molt --gateway-url <url>".');
+  }
+  const { MoltSDK } = await import("./dist-UYA4RJUH.mjs");
+  const sdk = await MoltSDK.create({
+    gatewayUrl: config.gateway.url,
+    authToken: config.gateway.authToken,
+    deviceId: config.gateway.deviceId,
+    devicePrivateKey: config.gateway.devicePrivateKey
+  });
+  return { sdk, sdkName };
+}
+function registerStartCommand(program) {
+  program.command("start").description("Start Moxxy orchestration").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const { MoltAgentSupervisor } = await import("./dist-7LTHRYKA.mjs");
+      const { IntegrationManager } = await import("./dist-LKIOZQ42.mjs");
+      const { GitHubIntegration } = await import("./dist-FAXRJMEN.mjs");
+      const provider = config.sdk || "molt";
+      const sdkName = SDK_NAMES[provider] || provider;
+      const connectSpinner = spinner(`Connecting to ${sdkName}`);
+      try {
+        const { sdk } = await createSDK(config);
+        connectSpinner.succeed(`Connected to ${sdkName}`);
+        const supervisorSpinner = spinner("Initializing agent supervisor");
+        const supervisor = new MoltAgentSupervisor(sdk);
+        const agentId = config.agent?.moltAgentId;
+        if (agentId) {
+          await supervisor.assignAgent(agentId, "developer");
+          supervisorSpinner.succeed(`Agent ${chalk.bold(agentId)} assigned`);
+        } else {
+          supervisorSpinner.succeed("Supervisor ready (no agent configured)");
+        }
+        const integrationManager = new IntegrationManager();
+        const github = new GitHubIntegration();
+        integrationManager.register(github);
+        integrationManager.on("*", (event) => {
+          info(
+            `${chalk.dim(`[${event.integration}]`)} ${event.type}: ${JSON.stringify(event.data).slice(0, 200)}`
+          );
+        });
+        const webhookConfig = config.webhook || {
+          port: 3456,
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        };
+        const webhookSpinner = spinner("Starting webhook server");
+        await github.connect({
+          github: config.github,
+          webhook: webhookConfig,
+          sdk,
+          supervisor,
+          moltAgentId: agentId || ""
+        });
+        webhookSpinner.succeed(
+          `Webhook server listening on ${chalk.cyan(`${webhookConfig.host}:${webhookConfig.port}${webhookConfig.path}`)}`
+        );
+        if (config.repos.length > 0) {
+          const watchSpinner = spinner(
+            `Watching ${config.repos.length} repositories`
+          );
+          const targets = config.repos.map((r) => `${r.owner}/${r.repo}`);
+          await github.watch(targets);
+          watchSpinner.succeed(
+            `Watching ${chalk.bold(String(targets.length))} repositories: ${targets.join(", ")}`
+          );
+        }
+        console.log();
+        success(chalk.bold("Moxxy is running.") + " Press Ctrl+C to stop.");
+        const shutdown = async () => {
+          console.log();
+          info("Shutting down...");
+          await integrationManager.stopAll();
+          sdk.disconnect();
+          success("Shutdown complete.");
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        await new Promise(() => {
+        });
+      } catch (innerErr) {
+        connectSpinner.fail(
+          `Failed to start: ${innerErr instanceof Error ? innerErr.message : innerErr}`
+        );
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      error(`Failed to start: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/repo.ts
+function registerRepoCommand(program) {
+  const repo = program.command("repo").description("Manage watched repositories");
+  repo.command("add").description("Add a repository to watch").argument("<repo>", "Repository in owner/repo format").option("--branch <branch>", "Default branch", "main").option("--events <events>", "Comma-separated events to watch", "issues.opened,issues.labeled").action(async (repoStr, options) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.addRepo({
+        owner,
+        repo: name,
+        defaultBranch: options.branch,
+        enabledEvents: options.events.split(",")
+      });
+      success(`Added ${chalk.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("list").description("List watched repositories").action(async () => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const config = manager.getConfig();
+      if (config.repos.length === 0) {
+        info("No repositories configured.");
+        return;
+      }
+      section(`Repositories (${config.repos.length})`);
+      for (const r of config.repos) {
+        listItem(
+          `${chalk.bold(`${r.owner}/${r.repo}`)} ${chalk.dim(`branch: ${r.defaultBranch}`)} ${chalk.dim(`events: ${r.enabledEvents.join(", ")}`)}`
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  repo.command("remove").description("Remove a watched repository").argument("<repo>", "Repository in owner/repo format").action(async (repoStr) => {
+    const [owner, name] = repoStr.split("/");
+    if (!owner || !name) {
+      error("Repository must be in owner/repo format");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      await manager.removeRepo(owner, name);
+      success(`Removed ${chalk.bold(`${owner}/${name}`)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/utils/prompt.ts
+import prompts from "prompts";
+import chalk2 from "chalk";
+async function interactiveInit() {
+  console.log();
+  console.log(chalk2.bold.cyan("  Moxxy Config Setup"));
+  console.log(chalk2.dim("  Answer the prompts below to initialize your configuration.\n"));
+  const { sdk } = await prompts({
+    type: "select",
+    name: "sdk",
+    message: "SDK provider",
+    choices: [
+      { title: "Molt", value: "molt" },
+      { title: "Claude", value: "claude" }
+    ]
+  });
+  if (!sdk) return null;
+  let gatewayUrl;
+  let authToken;
+  let claudeApiKey;
+  let claudeModel;
+  let claudeCliPath;
+  if (sdk === "molt") {
+    const molt = await prompts([
+      {
+        type: "text",
+        name: "gatewayUrl",
+        message: "Gateway URL",
+        validate: (v) => v.length > 0 ? true : "Gateway URL is required"
+      },
+      {
+        type: "text",
+        name: "authToken",
+        message: "Auth token (optional, press Enter to skip)"
+      }
+    ]);
+    if (!molt.gatewayUrl) return null;
+    gatewayUrl = molt.gatewayUrl;
+    authToken = molt.authToken || void 0;
+  } else {
+    const claude = await prompts([
+      {
+        type: "text",
+        name: "apiKey",
+        message: "Anthropic API key (optional, press Enter to skip)"
+      },
+      {
+        type: "text",
+        name: "model",
+        message: "Claude model",
+        initial: "claude-sonnet-4-5"
+      },
+      {
+        type: "text",
+        name: "cliPath",
+        message: "Claude CLI path",
+        initial: "claude"
+      }
+    ]);
+    if (claude.model === void 0) return null;
+    claudeApiKey = claude.apiKey || void 0;
+    claudeModel = claude.model;
+    claudeCliPath = claude.cliPath;
+  }
+  const shared = await prompts([
+    {
+      type: "password",
+      name: "githubToken",
+      message: "GitHub personal access token",
+      validate: (v) => v.length > 0 ? true : "GitHub token is required"
+    },
+    {
+      type: "password",
+      name: "webhookSecret",
+      message: "Webhook secret (optional, press Enter to skip)"
+    },
+    {
+      type: "number",
+      name: "webhookPort",
+      message: "Webhook port",
+      initial: 3456
+    },
+    {
+      type: "text",
+      name: "agentId",
+      message: "Agent ID (optional, press Enter to skip)"
+    }
+  ]);
+  if (!shared.githubToken) return null;
+  return {
+    sdk,
+    gatewayUrl,
+    authToken,
+    claudeApiKey,
+    claudeModel,
+    claudeCliPath,
+    githubToken: shared.githubToken,
+    webhookSecret: shared.webhookSecret || void 0,
+    webhookPort: String(shared.webhookPort ?? 3456),
+    agentId: shared.agentId || void 0
+  };
+}
+
+// src/commands/config.ts
+function registerConfigCommand(program) {
+  const config = program.command("config").description("Manage Moxxy configuration");
+  config.command("init").description("Initialize Moxxy configuration").option("--sdk <provider>", "SDK provider (molt or claude)").option("--github-token <token>", "GitHub personal access token").option("--gateway-url <url>", "Gateway URL (molt SDK)").option("--auth-token <token>", "Gateway auth token (molt SDK)").option("--claude-api-key <key>", "Anthropic API key (claude SDK)").option("--claude-model <model>", "Claude model (claude SDK)", "claude-sonnet-4-5").option("--claude-cli-path <path>", "Claude CLI path (claude SDK)", "claude").option("--webhook-secret <secret>", "GitHub webhook secret").option("--webhook-port <port>", "Webhook server port", "3456").option("--agent-id <id>", "Agent ID").action(async (options) => {
+    if (!options.sdk) {
+      const result = await interactiveInit();
+      if (!result) {
+        warn("Config init cancelled.");
+        return;
+      }
+      options = { ...options, ...result };
+    }
+    const sdk = options.sdk;
+    if (sdk !== "molt" && sdk !== "claude") {
+      error('--sdk must be "molt" or "claude"');
+      process.exitCode = 1;
+      return;
+    }
+    if (!options.githubToken) {
+      error("--github-token is required");
+      process.exitCode = 1;
+      return;
+    }
+    if (sdk === "molt" && !options.gatewayUrl) {
+      error("--gateway-url is required when using the molt SDK");
+      process.exitCode = 1;
+      return;
+    }
+    const manager = new ConfigManager();
+    try {
+      await manager.init({
+        version: 1,
+        sdk,
+        gateway: sdk === "molt" ? { url: options.gatewayUrl, authToken: options.authToken } : void 0,
+        github: { token: options.githubToken, webhookSecret: options.webhookSecret },
+        webhook: {
+          port: parseInt(options.webhookPort, 10),
+          host: "0.0.0.0",
+          path: "/webhook/github"
+        },
+        repos: [],
+        agent: options.agentId ? { moltAgentId: options.agentId } : void 0,
+        claude: sdk === "claude" ? {
+          apiKey: options.claudeApiKey,
+          cliPath: options.claudeCliPath,
+          model: options.claudeModel
+        } : void 0
+      });
+      success(`Config created at ${chalk.dim(manager.path)}`);
+    } catch (err) {
+      error(`Failed to init config: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("set").description("Set a config value").argument("<key>", "Config key (dot notation)").argument("<value>", "Config value").action(async (key, value) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      let parsed = value;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+      }
+      await manager.set(key, parsed);
+      success(`Set ${chalk.bold(key)}`);
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+  config.command("get").description("Get a config value").argument("<key>", "Config key (dot notation)").action(async (key) => {
+    const manager = new ConfigManager();
+    try {
+      await manager.load();
+      const value = manager.get(key);
+      console.log(chalk.cyan(JSON.stringify(value, null, 2)));
+    } catch (err) {
+      error(`Failed: ${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/status.ts
+function registerStatusCommand(program) {
+  program.command("status").description("Show Moxxy configuration status").action(async () => {
+    const configManager = new ConfigManager();
+    try {
+      const config = await configManager.load();
+      printBanner();
+      const provider = config.sdk || "molt";
+      section("SDK");
+      keyValue("Provider", chalk.bold(provider));
+      if (provider === "molt" && config.gateway) {
+        section("Gateway");
+        keyValue("URL", chalk.cyan(config.gateway.url));
+        keyValue(
+          "Auth",
+          config.gateway.authToken ? chalk.green("configured") : chalk.dim("not set")
+        );
+        keyValue(
+          "Device",
+          config.gateway.deviceId || chalk.dim("not set")
+        );
+      }
+      if (provider === "claude" && config.claude) {
+        section("Claude");
+        keyValue(
+          "API Key",
+          config.claude.apiKey ? chalk.yellow("***" + config.claude.apiKey.slice(-4)) : chalk.dim("not set")
+        );
+        keyValue("CLI Path", chalk.cyan(config.claude.cliPath || "claude"));
+        keyValue("Model", chalk.cyan(config.claude.model || "claude-sonnet-4-5"));
+      }
+      section("GitHub");
+      keyValue(
+        "Token",
+        config.github.token ? chalk.yellow("***" + config.github.token.slice(-4)) : chalk.dim("not set")
+      );
+      keyValue(
+        "Webhook Secret",
+        config.github.webhookSecret ? chalk.green("configured") : chalk.dim("not set")
+      );
+      if (config.webhook) {
+        section("Webhook Server");
+        keyValue("Port", chalk.cyan(String(config.webhook.port)));
+        keyValue("Path", chalk.cyan(config.webhook.path));
+      }
+      section(`Repositories (${config.repos.length})`);
+      if (config.repos.length === 0) {
+        keyValue("", chalk.dim("None configured"));
+      } else {
+        for (const r of config.repos) {
+          listItem(
+            `${chalk.bold(`${r.owner}/${r.repo}`)} ${chalk.dim(`(${r.defaultBranch})`)}`
+          );
+        }
+      }
+      if (config.agent) {
+        section("Agent");
+        keyValue(
+          "Agent ID",
+          config.agent.moltAgentId || chalk.dim("not set")
+        );
+        keyValue(
+          "Max Concurrent",
+          String(config.agent.maxConcurrentTasks || 1)
+        );
+      }
+      console.log();
+    } catch (err) {
+      error(`${err instanceof Error ? err.message : err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli.ts
+function createProgram() {
+  const program = new Command();
+  program.name("moxxy").description("Moxxy - Agent orchestration platform").version("1.0.0");
+  registerStartCommand(program);
+  registerRepoCommand(program);
+  registerConfigCommand(program);
+  registerStatusCommand(program);
+  return program;
+}
+
+export {
+  ConfigManager,
+  createProgram
+};