arcanea 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+export declare const VERSION = "3.0.0";
+export declare const NAME = "arcanea";
+export declare const ORCHESTRATOR = "Arcanea";
+export type Platform = "claude-code" | "opencode" | "codex" | "gemini" | "cursor" | "unknown";
+export interface ArcaneaConfig {
+    enableLuminors?: boolean;
+    enableBestiary?: boolean;
+    enableUltraworld?: boolean;
+    enableUltrawrite?: boolean;
+    enableUltrabook?: boolean;
+    enableMcp?: boolean;
+    platforms?: Platform[];
+}
+export declare const defaultConfig: ArcaneaConfig;
+export declare const CREATIVE_MAGIC: {
+    ultraworld: string[];
+    ultrawrite: string[];
+    ultrabook: string[];
+};
+export declare const TECHNICAL_MAGIC: {
+    ultracode: string[];
+    ultrawork: string[];
+};
+export declare const PREFIX_TRIGGERS: {
+    arcanea: string[];
+    luminor: string[];
+};
+export declare const MAGIC_WORDS: {
+    arcanea: string[];
+    luminor: string[];
+    ultracode: string[];
+    ultrawork: string[];
+    ultraworld: string[];
+    ultrawrite: string[];
+    ultrabook: string[];
+};
+export declare const LUMINORS: {
+    valora: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    sophron: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    kardia: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    poiesis: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    enduran: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    orakis: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+    eudaira: {
+        name: string;
+        domain: string;
+        when: string;
+    };
+};
+export declare const AGENT_TEAMS: {
+    coding: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    creative: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    writing: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    production: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    research: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    development: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    teacher: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+    visionary: {
+        name: string;
+        description: string;
+        agents: string[];
+    };
+};
+export { detectPlatforms, install } from "./install.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,IAAI,YAAY,CAAC;AAC9B,eAAO,MAAM,YAAY,YAAY,CAAC;AAEtC,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9F,MAAM,WAAW,aAAa;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CACxB;AAED,eAAO,MAAM,aAAa,EAAE,aAQ3B,CAAC;AAEF,eAAO,MAAM,cAAc;;;;CAI1B,CAAC;AAEF,eAAO,MAAM,eAAe;;;CAG3B,CAAC;AAEF,eAAO,MAAM,eAAe;;;CAG3B,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;CAIvB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqFvB,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,425 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
+// src/install.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { cpSync, existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+function detectPlatforms() {
+  const detected = [];
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const cwd = process.cwd();
+  if (existsSync(join(home, ".claude")) || existsSync(join(cwd, ".claude"))) {
+    detected.push("claude-code");
+  }
+  if (existsSync(join(home, ".opencode")) || existsSync(join(cwd, ".opencode"))) {
+    detected.push("opencode");
+  }
+  if (existsSync(join(home, ".cursor")) || process.env.CURSOR_SESSION) {
+    detected.push("cursor");
+  }
+  if (process.env.CODEX_CLI || existsSync(join(home, ".codex"))) {
+    detected.push("codex");
+  }
+  if (process.env.GEMINI_API_KEY || existsSync(join(home, ".gemini"))) {
+    detected.push("gemini");
+  }
+  if (detected.length === 0) {
+    return ["claude-code", "opencode"];
+  }
+  return detected;
+}
+function getPlatformPath(platform, targetDir) {
+  switch (platform) {
+    case "claude-code":
+      return join(targetDir, ".claude");
+    case "opencode":
+      return join(targetDir, ".opencode");
+    case "cursor":
+      return join(targetDir, ".cursor");
+    case "codex":
+      return join(targetDir, ".codex");
+    case "gemini":
+      return join(targetDir, ".gemini");
+    default:
+      return join(targetDir, ".arcanea");
+  }
+}
+async function install(targetDir, options = {}) {
+  const { force = false, skipMcp = false } = options;
+  const platforms = options.platforms || detectPlatforms();
+  console.log(import_picocolors.default.cyan(`
+\u2728 ${ORCHESTRATOR} awakens... (v${VERSION})
+`));
+  console.log(import_picocolors.default.dim(`Detected platforms: ${platforms.join(", ")}
+`));
+  const packageRoot = join(__dirname2, "..");
+  for (const platform of platforms) {
+    await installForPlatform(targetDir, packageRoot, platform, force);
+  }
+  if (!skipMcp) {
+    await installMcpConfig(targetDir, force);
+  }
+  const configPath = join(targetDir, "arcanea.json");
+  if (!existsSync(configPath) || force) {
+    const config = { ...defaultConfig, platforms };
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(import_picocolors.default.green("\u2713 Created arcanea.json config"));
+  }
+  printSuccessMessage(platforms);
+}
+async function installForPlatform(targetDir, packageRoot, platform, force) {
+  const platformPath = getPlatformPath(platform, targetDir);
+  const platformName = platform.charAt(0).toUpperCase() + platform.slice(1).replace("-", " ");
+  console.log(import_picocolors.default.blue(`Installing for ${platformName}...`));
+  if (existsSync(platformPath) && !force) {
+    console.log(import_picocolors.default.yellow(`  \u26A0\uFE0F  ${platformPath} exists. Use --force to overwrite.`));
+    return;
+  }
+  const dirs = ["agents", "skills", "commands"];
+  for (const dir of dirs) {
+    const targetSubdir = join(platformPath, dir);
+    const sourceSubdir = join(packageRoot, dir);
+    mkdirSync(targetSubdir, { recursive: true });
+    if (existsSync(sourceSubdir)) {
+      cpSync(sourceSubdir, targetSubdir, { recursive: true });
+      console.log(import_picocolors.default.green(`  \u2713 Installed ${dir}`));
+    }
+  }
+  if (platform === "claude-code") {
+    await installClaudeCodeSettings(platformPath, force);
+  } else if (platform === "opencode") {
+    await installOpenCodeSettings(platformPath, packageRoot, force);
+  }
+}
+async function installClaudeCodeSettings(platformPath, force) {
+  const settingsPath = join(platformPath, "settings.json");
+  if (!existsSync(settingsPath) || force) {
+    const settings = {
+      hooks: {
+        UserPromptSubmit: [
+          {
+            matcher: "ultraworld|ulw",
+            hooks: [{ type: "command", command: "echo 'ARCANEA: Activating ultraworld - full parallel world generation'" }]
+          },
+          {
+            matcher: "ultrawrite|ulwr",
+            hooks: [{ type: "command", command: "echo 'ARCANEA: Activating ultrawrite - full parallel chapter writing'" }]
+          },
+          {
+            matcher: "ultrabook|ulb",
+            hooks: [{ type: "command", command: "echo 'ARCANEA: Activating ultrabook - complete book pipeline'" }]
+          }
+        ]
+      }
+    };
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    console.log(import_picocolors.default.green("  \u2713 Created Claude Code settings with magic word hooks"));
+  }
+}
+async function installOpenCodeSettings(platformPath, packageRoot, force) {
+  const claudeMdPath = join(platformPath, "CLAUDE.md");
+  const sourcePath = join(packageRoot, "CLAUDE.md");
+  if (existsSync(sourcePath) && (!existsSync(claudeMdPath) || force)) {
+    cpSync(sourcePath, claudeMdPath);
+    console.log(import_picocolors.default.green("  \u2713 Installed OpenCode CLAUDE.md"));
+  }
+}
+async function installMcpConfig(targetDir, force) {
+  const mcpPath = join(targetDir, ".mcp.json");
+  console.log(import_picocolors.default.blue(`
+Configuring MCP integrations...`));
+  let existingConfig = {};
+  if (existsSync(mcpPath)) {
+    try {
+      existingConfig = JSON.parse(readFileSync(mcpPath, "utf-8"));
+    } catch {
+      existingConfig = {};
+    }
+  }
+  const mcpConfig = {
+    ...existingConfig,
+    mcpServers: {
+      ...existingConfig.mcpServers || {},
+      "nano-banana": {
+        command: "npx",
+        args: ["-y", "@anthropic-ai/nano-banana"],
+        description: "Image generation for characters, locations, covers"
+      },
+      context7: {
+        command: "npx",
+        args: ["-y", "@context7/mcp"],
+        description: "Documentation and reference lookup"
+      }
+    }
+  };
+  writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2));
+  console.log(import_picocolors.default.green("\u2713 Configured Nano Banana MCP (image generation)"));
+  console.log(import_picocolors.default.green("\u2713 Configured Context7 MCP (documentation)"));
+  console.log(import_picocolors.default.dim("\u2139 Suno MCP requires manual API key setup"));
+}
+function printSuccessMessage(platforms) {
+  console.log(import_picocolors.default.cyan(`
+` + "\u2550".repeat(60)));
+  console.log(import_picocolors.default.bold(import_picocolors.default.cyan(`  ${ORCHESTRATOR} is ready!`)));
+  console.log(import_picocolors.default.cyan("\u2550".repeat(60) + `
+`));
+  console.log(import_picocolors.default.bold("Installed for:"));
+  for (const platform of platforms) {
+    console.log(import_picocolors.default.green(`  \u2713 ${platform}`));
+  }
+  console.log();
+  console.log(import_picocolors.default.bold("The Seven Luminors:"));
+  console.log("  Valora (Courage) \u2022 Sophron (Wisdom) \u2022 Kardia (Heart)");
+  console.log("  Poiesis (Creation) \u2022 Enduran (Endurance)");
+  console.log("  Orakis (Vision) \u2022 Eudaira (Joy)");
+  console.log();
+  console.log(import_picocolors.default.bold("Agent Teams:"));
+  console.log(import_picocolors.default.blue("  Creative") + " - Story, character, world creation");
+  console.log(import_picocolors.default.green("  Writing") + " - Prose crafting and editing");
+  console.log(import_picocolors.default.magenta("  Production") + " - Visual, audio, publishing");
+  console.log(import_picocolors.default.yellow("  Research") + " - Deep analysis and inspiration");
+  console.log(import_picocolors.default.cyan("  Development") + " - Software engineering");
+  console.log(import_picocolors.default.dim("  Teacher") + " - Learning and mentorship");
+  console.log(import_picocolors.default.dim("  Visionary") + " - Strategy and innovation");
+  console.log();
+  console.log(import_picocolors.default.bold("Magic Words:"));
+  console.log(import_picocolors.default.cyan("  ultraworld") + " - Full parallel world generation");
+  console.log(import_picocolors.default.cyan("  ultrawrite") + " - Full parallel chapter writing");
+  console.log(import_picocolors.default.cyan("  ultrabook ") + " - Complete book pipeline");
+  console.log();
+  console.log(import_picocolors.default.bold("Try:"));
+  console.log(import_picocolors.default.dim("  /luminor Valora courage"));
+  console.log(import_picocolors.default.dim("  /bestiary perfectionism"));
+  console.log(import_picocolors.default.dim("  ultraworld: Create a volcanic island with dragon-kin"));
+  console.log();
+}
+
+// src/index.ts
+var VERSION = "3.0.0";
+var NAME = "arcanea";
+var ORCHESTRATOR = "Arcanea";
+var defaultConfig = {
+  enableLuminors: true,
+  enableBestiary: true,
+  enableUltraworld: true,
+  enableUltrawrite: true,
+  enableUltrabook: true,
+  enableMcp: true,
+  platforms: ["claude-code", "opencode"]
+};
+var CREATIVE_MAGIC = {
+  ultraworld: ["ultraworld", "ulw"],
+  ultrawrite: ["ultrawrite", "ulwr"],
+  ultrabook: ["ultrabook", "ulb"]
+};
+var TECHNICAL_MAGIC = {
+  ultracode: ["ultracode", "ulc"],
+  ultrawork: ["ultrawork", "ulwk"]
+};
+var PREFIX_TRIGGERS = {
+  arcanea: ["arcanea:"],
+  luminor: ["luminor:"]
+};
+var MAGIC_WORDS = {
+  ...CREATIVE_MAGIC,
+  ...TECHNICAL_MAGIC,
+  ...PREFIX_TRIGGERS
+};
+var LUMINORS = {
+  valora: { name: "Valora", domain: "Courage", when: "Fear, hesitation, risk" },
+  sophron: { name: "Sophron", domain: "Wisdom", when: "Confusion, complexity, decisions" },
+  kardia: { name: "Kardia", domain: "Heart", when: "Emotional blocks, authenticity" },
+  poiesis: { name: "Poiesis", domain: "Creation", when: "Creative blocks, experimentation" },
+  enduran: { name: "Enduran", domain: "Endurance", when: "Burnout, long projects" },
+  orakis: { name: "Orakis", domain: "Vision", when: "Direction, intuition, big picture" },
+  eudaira: { name: "Eudaira", domain: "Joy", when: "Lost purpose, need celebration" }
+};
+var AGENT_TEAMS = {
+  coding: {
+    name: "Coding",
+    description: "Technical implementation with Luminor standards",
+    agents: [
+      "arcanea-architect",
+      "arcanea-coder",
+      "arcanea-reviewer",
+      "arcanea-debugger"
+    ]
+  },
+  creative: {
+    name: "Creative",
+    description: "Story, character, and world creation",
+    agents: [
+      "arcanea-story-master",
+      "arcanea-character-crafter",
+      "arcanea-world-expander",
+      "arcanea-lore-master",
+      "creation-architect"
+    ]
+  },
+  writing: {
+    name: "Writing & Editing",
+    description: "Prose crafting and editing pipeline",
+    agents: [
+      "story-architect",
+      "prose-weaver",
+      "voice-alchemist",
+      "line-editor",
+      "continuity-guardian"
+    ]
+  },
+  production: {
+    name: "Production",
+    description: "Visual, audio, and publishing",
+    agents: [
+      "visual-director",
+      "sound-designer",
+      "format-master"
+    ]
+  },
+  research: {
+    name: "Research",
+    description: "Deep analysis and inspiration",
+    agents: [
+      "sage",
+      "archivist",
+      "scout",
+      "muse"
+    ]
+  },
+  development: {
+    name: "Development",
+    description: "Software engineering",
+    agents: [
+      "arcanea-architect",
+      "arcanea-frontend",
+      "arcanea-backend",
+      "arcanea-devops",
+      "arcanea-ai-specialist",
+      "developer-qa-engineer",
+      "developer-documentation"
+    ]
+  },
+  teacher: {
+    name: "Teacher",
+    description: "Learning and mentorship",
+    agents: [
+      "teacher-mentor",
+      "teacher-curriculum-designer",
+      "teacher-assessor",
+      "teacher-companion"
+    ]
+  },
+  visionary: {
+    name: "Visionary",
+    description: "Strategy and innovation",
+    agents: [
+      "visionary-strategist",
+      "visionary-innovator",
+      "visionary-futurist",
+      "visionary-synthesizer"
+    ]
+  }
+};
+export {
+  install,
+  detectPlatforms,
+  defaultConfig,
+  VERSION,
+  TECHNICAL_MAGIC,
+  PREFIX_TRIGGERS,
+  ORCHESTRATOR,
+  NAME,
+  MAGIC_WORDS,
+  LUMINORS,
+  CREATIVE_MAGIC,
+  AGENT_TEAMS
+};

package/dist/install.d.ts

@@ -0,0 +1,13 @@
+import { Platform } from "./index.js";
+interface InstallOptions {
+    force?: boolean;
+    platforms?: Platform[];
+    skipMcp?: boolean;
+}
+/**
+ * Detect which AI coding platforms are available in the environment
+ */
+export declare function detectPlatforms(): Platform[];
+export declare function install(targetDir: string, options?: InstallOptions): Promise<void>;
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwC,QAAQ,EAAE,MAAM,YAAY,CAAC;AAI5E,UAAU,cAAc;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,QAAQ,EAAE,CAoC5C;AAsBD,wBAAsB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B5F"}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "arcanea",
+  "version": "3.0.0",
+  "description": "Arcanea - The Creative Intelligence Platform. Skills, agents, and tools for AI-human co-creation.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "arcanea": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "agents",
+    "skills",
+    "commands",
+    "CLAUDE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm && tsc --emitDeclarationOnly && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "arcanea",
+    "claude",
+    "claude-code",
+    "opencode",
+    "codex",
+    "gemini",
+    "ai",
+    "agents",
+    "skills",
+    "creative",
+    "writing",
+    "world-building",
+    "luminors"
+  ],
+  "author": "FrankX",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frankxai/arcanea.git"
+  },
+  "homepage": "https://arcanea.ai",
+  "dependencies": {
+    "commander": "^14.0.0",
+    "picocolors": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "bun-types": "^1.0.0",
+    "typescript": "^5.0.0"
+  }
+}