@claude-collective/cli 0.21.0 → 0.25.1

package/dist/chunk-ZDREFYD2.js

@@ -0,0 +1,696 @@
+#!/usr/bin/env node
+import {
+  init_esm_shims
+} from "./chunk-AWKZ5BDL.js";
+
+// src/cli/utils/logger.ts
+init_esm_shims();
+var verboseMode = false;
+function setVerbose(enabled) {
+  verboseMode = enabled;
+}
+function verbose(msg) {
+  if (verboseMode) {
+    console.log(`  ${msg}`);
+  }
+}
+function warn(msg) {
+  console.warn(`  Warning: ${msg}`);
+}
+
+// src/cli/utils/fs.ts
+init_esm_shims();
+import fs from "fs-extra";
+import fg from "fast-glob";
+import path from "path";
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function readFileOptional(filePath, fallback = "") {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return fallback;
+  }
+}
+async function fileExists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listDirectories(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function glob(pattern, cwd) {
+  return fg(pattern, { cwd, onlyFiles: true });
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function remove(filePath) {
+  await fs.remove(filePath);
+}
+async function copy(src, dest) {
+  await fs.copy(src, dest);
+}
+
+// src/cli/lib/schemas.ts
+init_esm_shims();
+import { z } from "zod";
+var domainSchema = z.enum([
+  "web",
+  "web-extras",
+  "api",
+  "cli",
+  "mobile",
+  "shared"
+]);
+var skillSourceTypeSchema = z.enum([
+  "public",
+  "private",
+  "local"
+]);
+var skillSourceSchema = z.object({
+  name: z.string(),
+  type: skillSourceTypeSchema,
+  url: z.string().optional(),
+  version: z.string().optional(),
+  installed: z.boolean(),
+  installMode: z.enum(["plugin", "local"]).optional()
+}).passthrough();
+var boundSkillSchema = z.object({
+  id: z.string(),
+  sourceUrl: z.string(),
+  sourceName: z.string(),
+  boundTo: z.string(),
+  description: z.string().optional()
+});
+var subcategorySchema = z.enum([
+  // Web
+  "framework",
+  "meta-framework",
+  "styling",
+  "client-state",
+  "server-state",
+  "forms",
+  "testing",
+  "ui-components",
+  "mocking",
+  "error-handling",
+  "i18n",
+  "file-upload",
+  "files",
+  "utilities",
+  "realtime",
+  "animation",
+  "pwa",
+  "accessibility",
+  "web-performance",
+  // API
+  "api",
+  "database",
+  "auth",
+  "observability",
+  "analytics",
+  "email",
+  "performance",
+  // Mobile
+  "mobile-framework",
+  // Shared / Infrastructure
+  "monorepo",
+  "tooling",
+  "security",
+  "methodology",
+  "research",
+  "reviewing",
+  "ci-cd",
+  // CLI
+  "cli-framework",
+  "cli-prompts",
+  "cli-testing"
+]);
+var agentNameSchema = z.enum([
+  // Developers
+  "web-developer",
+  "api-developer",
+  "cli-developer",
+  "web-architecture",
+  // Meta
+  "agent-summoner",
+  "documentor",
+  "skill-summoner",
+  // Migration
+  "cli-migrator",
+  // Pattern
+  "pattern-scout",
+  "web-pattern-critique",
+  // Planning
+  "web-pm",
+  // Researchers
+  "api-researcher",
+  "web-researcher",
+  // Reviewers
+  "api-reviewer",
+  "cli-reviewer",
+  "web-reviewer",
+  // Testers
+  "cli-tester",
+  "web-tester"
+]);
+var modelNameSchema = z.enum([
+  "sonnet",
+  "opus",
+  "haiku",
+  "inherit"
+]);
+var permissionModeSchema = z.enum([
+  "default",
+  "acceptEdits",
+  "dontAsk",
+  "bypassPermissions",
+  "plan",
+  "delegate"
+]);
+var skillDisplayNameSchema = z.enum([
+  // Frameworks
+  "react",
+  "vue",
+  "angular",
+  "solidjs",
+  // Meta-frameworks
+  "nextjs-app-router",
+  "nextjs-server-actions",
+  "remix",
+  "nuxt",
+  // Styling
+  "scss-modules",
+  "cva",
+  "tailwind",
+  // Client State
+  "zustand",
+  "redux-toolkit",
+  "pinia",
+  "ngrx-signalstore",
+  "jotai",
+  "mobx",
+  // Server State / Data Fetching
+  "react-query",
+  "swr",
+  "graphql-apollo",
+  "graphql-urql",
+  "trpc",
+  // Forms & Validation
+  "react-hook-form",
+  "vee-validate",
+  "zod-validation",
+  // Testing
+  "vitest",
+  "playwright-e2e",
+  "cypress-e2e",
+  "react-testing-library",
+  "vue-test-utils",
+  "msw",
+  // UI Components
+  "shadcn-ui",
+  "tanstack-table",
+  "radix-ui",
+  // Backend - API Framework
+  "hono",
+  "express",
+  "fastify",
+  // Backend - Database
+  "drizzle",
+  "prisma",
+  // Backend - Auth
+  "better-auth",
+  // Backend - Observability
+  "axiom-pino-sentry",
+  // Backend - Analytics
+  "posthog",
+  "posthog-flags",
+  // Backend - Email
+  "resend",
+  // Backend - CI/CD
+  "github-actions",
+  // Mobile
+  "react-native",
+  "expo",
+  // Setup / Infrastructure
+  "turborepo",
+  "tooling",
+  "posthog-setup",
+  "env",
+  "observability-setup",
+  "email-setup",
+  // Animation / PWA / Realtime / etc.
+  "framer-motion",
+  "css-animations",
+  "view-transitions",
+  "storybook",
+  "error-boundaries",
+  "accessibility",
+  "websockets",
+  "sse",
+  "socket-io",
+  "service-workers",
+  "file-upload",
+  "image-handling",
+  "date-fns",
+  // Backend-specific category skills
+  "api-testing",
+  "api-performance",
+  "web-performance",
+  // Security
+  "security",
+  // CLI
+  "commander",
+  "cli-commander",
+  "oclif",
+  // Reviewing / Meta
+  "reviewing",
+  "cli-reviewing",
+  "research-methodology",
+  // Methodology
+  "investigation-requirements",
+  "anti-over-engineering",
+  "success-criteria",
+  "write-verification",
+  "improvement-protocol",
+  "context-management"
+]);
+var SKILL_ID_PATTERN = /^(web|api|cli|mobile|infra|meta|security)-.+-.+$/;
+var skillIdSchema = z.string().regex(
+  SKILL_ID_PATTERN,
+  "Must be a valid skill ID (e.g., 'web-framework-react')"
+);
+var categoryPathSchema = z.string().refine(
+  (val) => {
+    if (val === "local") return true;
+    if (/^(web|api|cli|mobile|infra|meta|security)\/.+$/.test(val)) return true;
+    if (/^(web|api|cli|mobile|infra|meta|security)-.+$/.test(val)) return true;
+    return subcategorySchema.safeParse(val).success;
+  },
+  {
+    message: "Must be a valid category path (e.g., 'web/framework', 'web-framework', 'testing', or 'local')"
+  }
+);
+var agentHookActionSchema = z.object({
+  type: z.enum(["command", "script", "prompt"]),
+  command: z.string().optional(),
+  script: z.string().optional(),
+  prompt: z.string().optional()
+});
+var agentHookDefinitionSchema = z.object({
+  matcher: z.string().optional(),
+  hooks: z.array(agentHookActionSchema).optional()
+});
+var hooksRecordSchema = z.record(z.string(), z.array(agentHookDefinitionSchema));
+var skillAssignmentSchema = z.object({
+  id: skillIdSchema,
+  preloaded: z.boolean().optional(),
+  local: z.boolean().optional(),
+  path: z.string().optional()
+});
+var skillFrontmatterSchema = z.object({
+  name: skillIdSchema,
+  description: z.string(),
+  model: modelNameSchema.optional()
+});
+var skillFrontmatterLoaderSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  model: modelNameSchema.optional()
+});
+var skillMetadataConfigSchema = z.object({
+  category: categoryPathSchema.optional(),
+  category_exclusive: z.boolean().optional(),
+  author: z.string().optional(),
+  version: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  requires: z.array(skillIdSchema).optional(),
+  compatible_with: z.array(skillIdSchema).optional(),
+  conflicts_with: z.array(skillIdSchema).optional()
+});
+var pluginAuthorSchema = z.object({
+  name: z.string(),
+  email: z.string().optional()
+});
+var pluginManifestSchema = z.object({
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  keywords: z.array(z.string()).optional(),
+  commands: z.union([z.string(), z.array(z.string())]).optional(),
+  agents: z.union([z.string(), z.array(z.string())]).optional(),
+  skills: z.union([z.string(), z.array(z.string())]).optional(),
+  hooks: z.union([z.string(), hooksRecordSchema]).optional()
+});
+var agentYamlConfigSchema = z.object({
+  id: agentNameSchema,
+  title: z.string(),
+  description: z.string(),
+  model: modelNameSchema.optional(),
+  tools: z.array(z.string()),
+  disallowed_tools: z.array(z.string()).optional(),
+  permission_mode: permissionModeSchema.optional(),
+  hooks: hooksRecordSchema.optional(),
+  output_format: z.string().optional()
+});
+var projectConfigSchema = z.object({
+  version: z.literal("1").optional(),
+  name: z.string(),
+  description: z.string().optional(),
+  agents: z.array(z.string()),
+  skills: z.array(skillIdSchema),
+  author: z.string().optional(),
+  installMode: z.enum(["local", "plugin"]).optional(),
+  stack: z.record(z.string(), z.record(subcategorySchema, skillIdSchema)).optional(),
+  source: z.string().optional(),
+  marketplace: z.string().optional(),
+  agents_source: z.string().optional()
+});
+var projectConfigLoaderSchema = z.object({
+  version: z.literal("1").optional(),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  agents: z.array(z.string()).optional(),
+  skills: z.array(skillIdSchema).optional(),
+  author: z.string().optional(),
+  installMode: z.enum(["local", "plugin"]).optional(),
+  stack: z.record(z.string(), z.record(z.string(), skillIdSchema)).optional(),
+  source: z.string().optional(),
+  marketplace: z.string().optional(),
+  agents_source: z.string().optional()
+}).passthrough();
+var validationResultSchema = z.object({
+  valid: z.boolean(),
+  errors: z.array(z.string()),
+  warnings: z.array(z.string())
+});
+var categoryDefinitionSchema = z.object({
+  id: subcategorySchema,
+  displayName: z.string(),
+  description: z.string(),
+  domain: domainSchema.optional(),
+  parent_domain: domainSchema.optional(),
+  exclusive: z.boolean(),
+  required: z.boolean(),
+  order: z.number(),
+  icon: z.string().optional()
+});
+var skillRefInYaml = z.string();
+var conflictRuleSchema = z.object({
+  skills: z.array(skillRefInYaml),
+  reason: z.string()
+});
+var discourageRuleSchema = z.object({
+  skills: z.array(skillRefInYaml),
+  reason: z.string()
+});
+var recommendRuleSchema = z.object({
+  when: skillRefInYaml,
+  suggest: z.array(skillRefInYaml),
+  reason: z.string()
+});
+var requireRuleSchema = z.object({
+  skill: skillRefInYaml,
+  needs: z.array(skillRefInYaml),
+  needs_any: z.boolean().optional(),
+  reason: z.string()
+});
+var alternativeGroupSchema = z.object({
+  purpose: z.string(),
+  skills: z.array(skillRefInYaml)
+});
+var relationshipDefinitionsSchema = z.object({
+  conflicts: z.array(conflictRuleSchema),
+  discourages: z.array(discourageRuleSchema),
+  recommends: z.array(recommendRuleSchema),
+  requires: z.array(requireRuleSchema),
+  alternatives: z.array(alternativeGroupSchema)
+});
+var skillsMatrixConfigSchema = z.object({
+  version: z.string(),
+  categories: z.record(subcategorySchema, categoryDefinitionSchema),
+  relationships: relationshipDefinitionsSchema,
+  skill_aliases: z.record(skillDisplayNameSchema, skillIdSchema)
+});
+var localRawMetadataSchema = z.object({
+  cli_name: z.string().optional(),
+  cli_description: z.string().optional(),
+  category: categoryPathSchema.optional(),
+  category_exclusive: z.boolean().optional(),
+  usage_guidance: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  compatible_with: z.array(skillIdSchema).optional(),
+  conflicts_with: z.array(skillIdSchema).optional(),
+  requires: z.array(skillIdSchema).optional(),
+  requires_setup: z.array(skillIdSchema).optional(),
+  provides_setup_for: z.array(skillIdSchema).optional()
+}).passthrough();
+var localSkillMetadataSchema = z.object({
+  forked_from: z.object({
+    skill_id: skillIdSchema,
+    content_hash: z.string(),
+    date: z.string()
+  }).optional()
+}).passthrough();
+var stackAgentConfigSchema = z.record(
+  z.string(),
+  z.string()
+);
+var stackSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  agents: z.record(z.string(), stackAgentConfigSchema),
+  philosophy: z.string().optional()
+});
+var stacksConfigSchema = z.object({
+  stacks: z.array(stackSchema)
+});
+var marketplaceRemoteSourceSchema = z.object({
+  source: z.enum(["github", "url"]),
+  repo: z.string().optional(),
+  url: z.string().optional(),
+  ref: z.string().optional()
+});
+var marketplacePluginSchema = z.object({
+  name: z.string(),
+  source: z.union([z.string(), marketplaceRemoteSourceSchema]),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  category: z.string().optional(),
+  keywords: z.array(z.string()).optional()
+});
+var marketplaceOwnerSchema = z.object({
+  name: z.string(),
+  email: z.string().optional()
+});
+var marketplaceMetadataSchema = z.object({
+  pluginRoot: z.string().optional()
+});
+var marketplaceSchema = z.object({
+  $schema: z.string().optional(),
+  name: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  owner: marketplaceOwnerSchema,
+  metadata: marketplaceMetadataSchema.optional(),
+  plugins: z.array(marketplacePluginSchema)
+});
+var versionedMetadataSchema = z.object({
+  version: z.number(),
+  content_hash: z.string().optional(),
+  updated: z.string().optional()
+}).passthrough();
+var defaultMappingsSchema = z.object({
+  skill_to_agents: z.record(z.string(), z.array(z.string())),
+  preloaded_skills: z.record(z.string(), z.array(z.string())),
+  subcategory_aliases: z.record(z.string(), z.string())
+});
+var permissionConfigSchema = z.object({
+  allow: z.array(z.string()).optional(),
+  deny: z.array(z.string()).optional()
+});
+var settingsFileSchema = z.object({
+  permissions: permissionConfigSchema.optional()
+}).passthrough();
+var importedSkillMetadataSchema = z.object({
+  forked_from: z.object({
+    source: z.string(),
+    skill_name: z.string(),
+    content_hash: z.string(),
+    date: z.string()
+  }).optional()
+}).passthrough();
+var projectSourceConfigSchema = z.object({
+  source: z.string().optional(),
+  author: z.string().optional(),
+  marketplace: z.string().optional(),
+  agents_source: z.string().optional(),
+  sources: z.array(
+    z.object({
+      name: z.string(),
+      url: z.string(),
+      description: z.string().optional(),
+      ref: z.string().optional()
+    })
+  ).optional(),
+  boundSkills: z.array(boundSkillSchema).optional()
+}).passthrough();
+var KEBAB_CASE_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var agentYamlGenerationSchema = z.object({
+  $schema: z.string().optional(),
+  id: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().min(1),
+  model: modelNameSchema.optional(),
+  tools: z.array(z.string()),
+  disallowed_tools: z.array(z.string()).optional(),
+  permission_mode: permissionModeSchema.optional(),
+  hooks: hooksRecordSchema.optional(),
+  output_format: z.string().optional()
+}).strict();
+var agentFrontmatterValidationSchema = z.object({
+  name: z.string().regex(KEBAB_CASE_PATTERN).min(1),
+  description: z.string().min(1),
+  tools: z.string().optional(),
+  disallowedTools: z.string().optional(),
+  model: modelNameSchema.optional(),
+  permissionMode: permissionModeSchema.optional(),
+  skills: z.array(z.string().min(1)).optional(),
+  hooks: hooksRecordSchema.optional()
+}).strict();
+var skillFrontmatterValidationSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  "disable-model-invocation": z.boolean().optional(),
+  "user-invocable": z.boolean().optional(),
+  "allowed-tools": z.string().optional(),
+  model: modelNameSchema.optional(),
+  context: z.enum(["fork"]).optional(),
+  agent: z.string().optional(),
+  "argument-hint": z.string().optional()
+}).strict();
+var metadataValidationSchema = z.object({
+  category: z.string(),
+  category_exclusive: z.boolean().optional(),
+  author: z.string().regex(/^@[a-z][a-z0-9-]*$/),
+  version: z.number().int().min(1).optional(),
+  cli_name: z.string().min(1).max(30),
+  cli_description: z.string().min(1).max(60),
+  usage_guidance: z.string().min(10),
+  requires: z.array(z.string().min(1)).optional(),
+  compatible_with: z.array(z.string().min(1)).optional(),
+  conflicts_with: z.array(z.string().min(1)).optional(),
+  tags: z.array(z.string().regex(/^[a-z][a-z0-9-]*$/)).optional(),
+  requires_setup: z.array(z.string().min(1)).optional(),
+  provides_setup_for: z.array(z.string().min(1)).optional(),
+  content_hash: z.string().regex(/^[a-f0-9]{7}$/).optional(),
+  updated: z.string().optional(),
+  forked_from: z.object({
+    skill_id: z.string(),
+    version: z.number().int().min(1).optional(),
+    content_hash: z.string(),
+    source: z.string().optional(),
+    date: z.string()
+  }).optional()
+}).strict();
+var stackSkillAssignmentSchema = z.object({
+  id: z.string().min(1),
+  preloaded: z.boolean().optional()
+}).strict();
+var stackConfigValidationSchema = z.object({
+  id: z.string().regex(KEBAB_CASE_PATTERN).optional(),
+  name: z.string().min(1),
+  version: z.string(),
+  author: z.string().min(1),
+  description: z.string().optional(),
+  created: z.string().optional(),
+  updated: z.string().optional(),
+  framework: z.string().optional(),
+  skills: z.array(stackSkillAssignmentSchema).min(1),
+  agents: z.array(z.string().regex(KEBAB_CASE_PATTERN)).min(1),
+  agent_skills: z.record(z.string(), z.record(z.string(), z.array(stackSkillAssignmentSchema))).optional(),
+  philosophy: z.string().optional(),
+  principles: z.array(z.string().min(1)).optional(),
+  tags: z.array(z.string().regex(KEBAB_CASE_PATTERN)).optional(),
+  overrides: z.record(
+    z.string(),
+    z.object({
+      alternatives: z.array(z.string().min(1)).optional(),
+      locked: z.boolean().optional()
+    }).strict()
+  ).optional(),
+  metrics: z.object({
+    upvotes: z.number().int().min(0).optional(),
+    downloads: z.number().int().min(0).optional()
+  }).strict().optional(),
+  hooks: z.record(
+    z.string(),
+    z.array(
+      z.object({
+        matcher: z.string().optional(),
+        hooks: z.array(agentHookActionSchema).min(1)
+      })
+    )
+  ).optional()
+}).strict();
+
+export {
+  setVerbose,
+  verbose,
+  warn,
+  readFile,
+  readFileOptional,
+  fileExists,
+  directoryExists,
+  listDirectories,
+  glob,
+  writeFile,
+  ensureDir,
+  remove,
+  copy,
+  skillDisplayNameSchema,
+  skillIdSchema,
+  categoryPathSchema,
+  hooksRecordSchema,
+  skillFrontmatterLoaderSchema,
+  skillMetadataConfigSchema,
+  pluginAuthorSchema,
+  pluginManifestSchema,
+  agentYamlConfigSchema,
+  projectConfigLoaderSchema,
+  skillsMatrixConfigSchema,
+  localRawMetadataSchema,
+  localSkillMetadataSchema,
+  stacksConfigSchema,
+  marketplaceSchema,
+  settingsFileSchema,
+  importedSkillMetadataSchema,
+  projectSourceConfigSchema,
+  agentYamlGenerationSchema,
+  agentFrontmatterValidationSchema,
+  skillFrontmatterValidationSchema,
+  metadataValidationSchema,
+  stackConfigValidationSchema
+};
+//# sourceMappingURL=chunk-ZDREFYD2.js.map