calabasas 0.11.0 → 0.12.0

package/dist/config.d.ts

@@ -9,9 +9,21 @@ export type SyncConfig = {
   presence?: boolean;
 };
 
-export type EventConfig = {
-  [eventType: string]: true;
-};
+export type DiscordEventName =
+  | "messageCreate"
+  | "messageUpdate"
+  | "messageDelete"
+  | "guildMemberAdd"
+  | "guildMemberRemove"
+  | "guildMemberUpdate"
+  | "interactionCreate"
+  | "voiceStateUpdate"
+  | "presenceUpdate"
+  | "typingStart"
+  | "messageReactionAdd"
+  | "messageReactionRemove";
+
+export type EventConfig = { [K in DiscordEventName]?: true };
 
 export type CommandOptionType = "string" | "integer" | "number" | "boolean" | "user" | "channel" | "role" | "mentionable" | "attachment";
 

package/dist/index.js

@@ -5425,6 +5425,358 @@ async function botEdit(botId, options) {
   p10.outro("Bot updated successfully!");
 }
 
+// src/commands/config.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+import * as p11 from "@clack/prompts";
+import pc2 from "picocolors";
+
+// src/lib/configSerializer.ts
+function indent(str, level) {
+  return str.split(`
+`).map((line) => line.trim() === "" ? "" : "  ".repeat(level) + line).join(`
+`);
+}
+function serializeValue(value, depth) {
+  if (value === null || value === undefined)
+    return "null";
+  if (typeof value === "boolean")
+    return String(value);
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const allPrimitive = value.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean");
+    if (allPrimitive && value.length <= 5) {
+      return `[${value.map((v) => serializeValue(v, depth + 1)).join(", ")}]`;
+    }
+    const items = value.map((v) => indent(serializeValue(v, depth + 1), depth + 1));
+    return `[
+${items.join(`,
+`)}
+${"  ".repeat(depth)}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return "{}";
+    const lines = entries.map(([key, val]) => {
+      const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+      return `${"  ".repeat(depth + 1)}${safeKey}: ${serializeValue(val, depth + 1)},`;
+    });
+    return `{
+${lines.join(`
+`)}
+${"  ".repeat(depth)}}`;
+  }
+  return String(value);
+}
+function serializeConfig(config) {
+  const sections = [];
+  if (config.intents && config.intents.length > 0) {
+    const items = config.intents.map((name) => JSON.stringify(name)).join(", ");
+    sections.push(`  intents: [${items}],`);
+  }
+  if (config.sync) {
+    const syncLines = Object.entries(config.sync).map(([key, val]) => `    ${key}: ${val},`);
+    sections.push(`  sync: {
+${syncLines.join(`
+`)}
+  },`);
+  }
+  if (config.events) {
+    const eventKeys = Object.keys(config.events);
+    if (eventKeys.length > 0) {
+      const eventLines = eventKeys.map((key) => `    ${key}: true,`);
+      sections.push(`  events: {
+${eventLines.join(`
+`)}
+  },`);
+    }
+  }
+  if (config.commands) {
+    const commandKeys = Object.keys(config.commands);
+    if (commandKeys.length > 0) {
+      const commandLines = commandKeys.map((name) => {
+        const def = config.commands[name];
+        const serialized = serializeValue(def, 2);
+        return `    ${name}: ${serialized},`;
+      });
+      sections.push(`  commands: {
+${commandLines.join(`
+`)}
+  },`);
+    }
+  }
+  return [
+    `import { defineCalabasas } from "calabasas";`,
+    ``,
+    `export default defineCalabasas({`,
+    sections.join(`
+`),
+    `});`,
+    ``
+  ].join(`
+`);
+}
+
+// src/lib/events.ts
+var DISCORD_EVENTS_META = {
+  messageCreate: { intent: "GuildMessages", privileged: false },
+  messageUpdate: { intent: "GuildMessages", privileged: false },
+  messageDelete: { intent: "GuildMessages", privileged: false },
+  guildMemberAdd: { intent: "GuildMembers", privileged: true },
+  guildMemberRemove: { intent: "GuildMembers", privileged: true },
+  guildMemberUpdate: { intent: "GuildMembers", privileged: true },
+  interactionCreate: { intent: null, privileged: false },
+  voiceStateUpdate: { intent: "GuildVoiceStates", privileged: false },
+  presenceUpdate: { intent: "GuildPresences", privileged: true },
+  typingStart: { intent: "GuildMessageTyping", privileged: false },
+  messageReactionAdd: { intent: "GuildMessageReactions", privileged: false },
+  messageReactionRemove: { intent: "GuildMessageReactions", privileged: false }
+};
+
+// src/lib/sync.ts
+var SYNC_PROPERTIES_META = {
+  guilds: { intent: null, privileged: false, description: "Sync guild/server info" },
+  channels: { intent: null, privileged: false, description: "Sync channels" },
+  roles: { intent: null, privileged: false, description: "Sync roles" },
+  members: { intent: "GuildMembers", privileged: true, description: "Sync members" },
+  presence: { intent: "GuildPresences", privileged: true, description: "Sync online status" }
+};
+
+// src/commands/config.ts
+var ALL_EVENTS = Object.keys(DISCORD_EVENTS_META);
+var ALL_SYNC = Object.keys(SYNC_PROPERTIES_META);
+function resolveConfigPath(configOption) {
+  return path8.resolve(process.cwd(), configOption);
+}
+function validateEventNames(names) {
+  const valid = [];
+  const invalid = [];
+  for (const name of names) {
+    if (ALL_EVENTS.includes(name)) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+  return { valid, invalid };
+}
+function validateSyncNames(names) {
+  const valid = [];
+  const invalid = [];
+  for (const name of names) {
+    if (ALL_SYNC.includes(name)) {
+      valid.push(name);
+    } else {
+      invalid.push(name);
+    }
+  }
+  return { valid, invalid };
+}
+function intentHint(intent, privileged) {
+  if (!intent)
+    return "";
+  const tag = privileged ? pc2.yellow(`requires ${intent} privileged intent`) : pc2.dim(`requires ${intent} intent`);
+  return `  ${tag}`;
+}
+function listConfig(config, configPath) {
+  const relPath = path8.relative(process.cwd(), configPath);
+  console.log(`
+${pc2.bold("Calabasas Config")} ${pc2.dim(`(${relPath})`)}
+`);
+  console.log(pc2.bold("Sync:"));
+  for (const key of ALL_SYNC) {
+    const meta = SYNC_PROPERTIES_META[key];
+    const enabled = config.sync?.[key] === true;
+    const dot = enabled ? pc2.green("  ●") : pc2.dim("  ○");
+    const hint = !enabled ? intentHint(meta.intent, meta.privileged) : "";
+    console.log(`${dot} ${key}${hint}`);
+  }
+  console.log(`
+${pc2.bold("Events:")}`);
+  const enabledEvents = new Set(Object.keys(config.events ?? {}));
+  for (const key of ALL_EVENTS) {
+    const meta = DISCORD_EVENTS_META[key];
+    const enabled = enabledEvents.has(key);
+    const dot = enabled ? pc2.green("  ●") : pc2.dim("  ○");
+    const hint = !enabled ? intentHint(meta.intent, meta.privileged) : "";
+    console.log(`${dot} ${key}${hint}`);
+  }
+  const commandNames = Object.keys(config.commands ?? {});
+  if (commandNames.length > 0) {
+    console.log(`
+${pc2.bold("Commands:")}`);
+    for (const name of commandNames) {
+      console.log(`  /${name} — ${config.commands[name].description}`);
+    }
+  }
+  console.log("");
+}
+async function interactiveConfig(config, configPath) {
+  p11.intro("calabasas config");
+  const syncSelection = await p11.multiselect({
+    message: "Select sync properties to enable",
+    options: ALL_SYNC.map((key) => {
+      const meta = SYNC_PROPERTIES_META[key];
+      const hint = meta.privileged ? `${meta.description} (Privileged)` : meta.description;
+      return {
+        value: key,
+        label: meta.privileged ? pc2.yellow(key) : key,
+        hint
+      };
+    }),
+    initialValues: ALL_SYNC.filter((key) => config.sync?.[key] === true),
+    required: false
+  });
+  if (p11.isCancel(syncSelection)) {
+    p11.cancel("Cancelled.");
+    return;
+  }
+  const eventSelection = await p11.multiselect({
+    message: "Select events to enable",
+    options: ALL_EVENTS.map((key) => {
+      const meta = DISCORD_EVENTS_META[key];
+      const hint = meta.intent ? meta.privileged ? `${meta.intent} (Privileged)` : meta.intent : "No intent required";
+      return {
+        value: key,
+        label: meta.privileged ? pc2.yellow(key) : key,
+        hint
+      };
+    }),
+    initialValues: Object.keys(config.events ?? {}),
+    required: false
+  });
+  if (p11.isCancel(eventSelection)) {
+    p11.cancel("Cancelled.");
+    return;
+  }
+  const selectedSync = new Set(syncSelection);
+  const selectedEvents = new Set(eventSelection);
+  const newConfig = { ...config };
+  const newSync = {};
+  for (const key of ALL_SYNC) {
+    newSync[key] = selectedSync.has(key);
+  }
+  newConfig.sync = newSync;
+  const newEvents = {};
+  for (const key of selectedEvents) {
+    newEvents[key] = true;
+  }
+  newConfig.events = newEvents;
+  const oldSync = config.sync ?? {};
+  const oldEvents = new Set(Object.keys(config.events ?? {}));
+  const syncChanged = ALL_SYNC.some((key) => oldSync[key] === true !== selectedSync.has(key));
+  const eventsChanged = selectedEvents.size !== oldEvents.size || [...selectedEvents].some((e) => !oldEvents.has(e));
+  if (!syncChanged && !eventsChanged) {
+    p11.outro("No changes.");
+    return;
+  }
+  const changes = [];
+  for (const key of ALL_SYNC) {
+    const was = oldSync[key] === true;
+    const now = selectedSync.has(key);
+    if (was && !now)
+      changes.push(`sync.${key}: ${pc2.red("enabled → disabled")}`);
+    if (!was && now)
+      changes.push(`sync.${key}: ${pc2.green("disabled → enabled")}`);
+  }
+  for (const key of ALL_EVENTS) {
+    const was = oldEvents.has(key);
+    const now = selectedEvents.has(key);
+    if (was && !now)
+      changes.push(`events.${key}: ${pc2.red("enabled → disabled")}`);
+    if (!was && now)
+      changes.push(`events.${key}: ${pc2.green("disabled → enabled")}`);
+  }
+  p11.note(changes.join(`
+`), "Changes");
+  const source = serializeConfig(newConfig);
+  fs8.writeFileSync(configPath, source);
+  p11.log.info(pc2.dim("Note: Comments in the original file are not preserved."));
+  p11.outro(`Updated ${path8.relative(process.cwd(), configPath)}. Run ${pc2.cyan("`calabasas generate`")} to regenerate code.`);
+}
+async function config(options) {
+  const configPath = resolveConfigPath(options.config);
+  if (!fs8.existsSync(configPath)) {
+    console.error(`Error: Config file not found: ${configPath}`);
+    console.error(`
+Run ${pc2.cyan("`calabasas init`")} first.`);
+    process.exit(1);
+  }
+  const currentConfig = await parseConfigFile(configPath);
+  if (options.list) {
+    listConfig(currentConfig, configPath);
+    return;
+  }
+  const hasFlags = options.addEvent?.length || options.removeEvent?.length || options.addSync?.length || options.removeSync?.length;
+  if (hasFlags) {
+    if (options.addEvent?.length) {
+      const { invalid } = validateEventNames(options.addEvent);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown event names: ${invalid.join(", ")}`);
+        console.error(`Valid events: ${ALL_EVENTS.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.removeEvent?.length) {
+      const { invalid } = validateEventNames(options.removeEvent);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown event names: ${invalid.join(", ")}`);
+        console.error(`Valid events: ${ALL_EVENTS.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.addSync?.length) {
+      const { invalid } = validateSyncNames(options.addSync);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown sync properties: ${invalid.join(", ")}`);
+        console.error(`Valid properties: ${ALL_SYNC.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    if (options.removeSync?.length) {
+      const { invalid } = validateSyncNames(options.removeSync);
+      if (invalid.length > 0) {
+        console.error(`Error: Unknown sync properties: ${invalid.join(", ")}`);
+        console.error(`Valid properties: ${ALL_SYNC.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    const newConfig = { ...currentConfig };
+    if (options.addSync?.length || options.removeSync?.length) {
+      const sync = { ...currentConfig.sync };
+      for (const name of options.addSync ?? []) {
+        sync[name] = true;
+      }
+      for (const name of options.removeSync ?? []) {
+        sync[name] = false;
+      }
+      newConfig.sync = sync;
+    }
+    if (options.addEvent?.length || options.removeEvent?.length) {
+      const events = { ...currentConfig.events };
+      for (const name of options.addEvent ?? []) {
+        events[name] = true;
+      }
+      for (const name of options.removeEvent ?? []) {
+        delete events[name];
+      }
+      newConfig.events = events;
+    }
+    const source = serializeConfig(newConfig);
+    fs8.writeFileSync(configPath, source);
+    console.log(`Updated ${path8.relative(process.cwd(), configPath)}.`);
+    console.log(`Run ${pc2.cyan("`calabasas generate`")} to regenerate code.`);
+    return;
+  }
+  await interactiveConfig(currentConfig, configPath);
+}
+
 // src/index.ts
 var dashboard = async (...args) => {
   const mod = await import("./dashboard-r2cptf7m.js");
@@ -5444,6 +5796,7 @@ program2.command("generate").description("Generate type-safe Discord handlers an
 program2.command("skill").description("Generate Calabasas documentation for AI assistants").option("--dev", "Use development environment").option("--prod", "Use production environment").option("-f, --file <path>", "Target file path (e.g. CLAUDE.md)").option("-y, --yes", "Auto-confirm replacing existing guidelines").action(skill);
 program2.command("add [components...]").description("Add Discord UI components to your project").action(add);
 program2.command("migrate [name]").description("Run a codemod migration (list available if no name given)").action(migrate);
+program2.command("config").description("View and modify your Calabasas config").option("-c, --config <path>", "Path to config file", "convex/calabasas/config.ts").option("-l, --list", "List current and available config options").option("--add-event <events...>", "Enable event handlers").option("--remove-event <events...>", "Disable event handlers").option("--add-sync <properties...>", "Enable sync properties").option("--remove-sync <properties...>", "Disable sync properties").action(config);
 program2.command("status").alias("dashboard").description("Real-time dashboard showing bot status, events, and stats").option("--dev", "Use development environment").option("--prod", "Use production environment").action(dashboard);
 program2.command("logs [botId]").description("Live event log viewer for a bot").option("-n, --limit <number>", "Number of log entries to show", "50").option("--dev", "Use development environment").option("--prod", "Use production environment").action(logs);
 var bot = program2.command("bot").description("Manage Discord bots");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calabasas",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "CLI for Calabasas - Discord Gateway as a Service for Convex",
   "type": "module",
   "bin": {