@gonzih/cc-discord 0.1.0 → 0.1.1

package/dist/bot.d.ts

@@ -33,6 +33,8 @@ export declare class CcDiscordBot {
     constructor(opts: DiscordBotOptions);
     /** Reverse-lookup: find the channelId string for a cron-stored integer */
     private snowflakeMap;
+    /** Channels created by the bot for a meta-agent namespace → skip local Claude session */
+    private channelNamespaceMap;
     private storeSnowflake;
     private reverseSnowflakeLookup;
     /** Session key: "channelId" or "channelId:threadId" for threads */
@@ -64,6 +66,11 @@ export declare class CcDiscordBot {
      */
     callCcAgentTool(toolName: string, args?: Record<string, unknown>): Promise<string | null>;
     private runCronTask;
+    /**
+     * Create a new Discord text channel for `namespace`, register it in channelNamespaceMap,
+     * and start the meta-agent for `repoUrl`. Fire-and-forget after sending the confirmation message.
+     */
+    private createChannelForRepo;
     /** Write a message to the Redis chat log. Fire-and-forget. */
     private writeChatMessage;
     /** Returns the last channelId that sent a message. */

package/dist/bot.js

@@ -13,7 +13,7 @@ import { formatForDiscord, splitLongMessage, stripAnsi } from "./formatter.js";
 import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
 import { CronManager } from "./cron.js";
-import { parseRoutingTag, ensureMetaAgent, routeToMetaAgent } from "./router.js";
+import { parseRoutingTag, parseChannelCreateIntent, ensureMetaAgent, routeToMetaAgent } from "./router.js";
 import { metaAgentStatusKey } from "@gonzih/cc-wire";
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
 function snowflakeToInt(id) {
@@ -139,6 +139,8 @@ export class CcDiscordBot {
     }
     /** Reverse-lookup: find the channelId string for a cron-stored integer */
     snowflakeMap = new Map();
+    /** Channels created by the bot for a meta-agent namespace → skip local Claude session */
+    channelNamespaceMap = new Map();
     storeSnowflake(channelId) {
         const n = snowflakeToInt(channelId);
         this.snowflakeMap.set(n, channelId);
@@ -255,6 +257,27 @@ export class CcDiscordBot {
         text = text.replace(/<@!?\d+>/g, "").trim();
         if (!text)
             return;
+        // Natural-language channel creation: "channel for https://github.com/org/repo"
+        if (this.redis) {
+            const intent = parseChannelCreateIntent(text);
+            if (intent) {
+                await this.createChannelForRepo(msg, intent.namespace, intent.repoUrl);
+                return;
+            }
+        }
+        // Channel registered via createChannelForRepo or /channel — route directly to its meta-agent
+        const mappedNs = this.channelNamespaceMap.get(effectiveChannelId);
+        if (mappedNs && this.redis) {
+            this.writeChatMessage("user", "discord", text, effectiveChannelId);
+            this.opts.registerRoutedChannelId?.(mappedNs.namespace, effectiveChannelId);
+            try {
+                await routeToMetaAgent(mappedNs.namespace, text, this.redis);
+            }
+            catch (err) {
+                await msg.channel.send(`Failed to route to ${mappedNs.namespace}: ${err.message}`).catch(() => { });
+            }
+            return;
+        }
         // #tag / #org/repo routing — delegate to meta-agent
         if (this.redis) {
             const routing = parseRoutingTag(text);
@@ -463,7 +486,9 @@ export class CcDiscordBot {
         session.flushTimer = null;
         if (!text)
             return;
-        this.writeChatMessage("assistant", "claude", text, channelId);
+        // Use source="discord" so the notifier's pmessage guard (source !== "claude") drops it
+        // and does not re-send this message as a second Discord notification.
+        this.writeChatMessage("assistant", "discord", text, channelId);
         await this.sendToChannel(channel, text);
     }
     startTyping(channelId, channel, session) {
@@ -535,6 +560,10 @@ export class CcDiscordBot {
                 .setName("wiki")
                 .setDescription("Wiki page info (pass namespace to look up)")
                 .addStringOption((opt) => opt.setName("namespace").setDescription("Namespace to look up").setRequired(false)),
+            new SlashCommandBuilder()
+                .setName("channel")
+                .setDescription("Create a Discord channel for a GitHub repo meta-agent")
+                .addStringOption((opt) => opt.setName("repo").setDescription("GitHub repo URL (e.g. https://github.com/org/repo)").setRequired(true)),
         ].map((cmd) => cmd.toJSON());
         const rest = new REST().setToken(this.opts.discordToken);
         if (this.opts.guildIds?.length) {
@@ -624,6 +653,39 @@ export class CcDiscordBot {
                 }
                 break;
             }
+            case "channel": {
+                const repoUrl = interaction.options.getString("repo", true);
+                const urlMatch = repoUrl.match(/^https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)/i);
+                if (!urlMatch) {
+                    await interaction.reply({ content: "Invalid repo URL. Use: https://github.com/org/repo", ephemeral: true });
+                    return;
+                }
+                const namespace = urlMatch[2];
+                const guild = interaction.guild;
+                if (!guild) {
+                    await interaction.reply({ content: "Channel creation requires a guild (not available in DMs).", ephemeral: true });
+                    return;
+                }
+                await interaction.deferReply();
+                try {
+                    const newChannel = await guild.channels.create({ name: namespace, type: ChannelType.GuildText });
+                    this.channelNamespaceMap.set(newChannel.id, { namespace, repoUrl });
+                    this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
+                    await interaction.editReply(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`);
+                    // Start meta-agent in the background
+                    if (this.redis) {
+                        ensureMetaAgent(namespace, repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis)
+                            .catch((err) => {
+                            console.error(`[bot] /channel ensureMetaAgent(${namespace}) failed:`, err.message);
+                            this.sendToChannelById(newChannel.id, `Warning: meta-agent startup failed — ${err.message}`).catch(() => { });
+                        });
+                    }
+                }
+                catch (err) {
+                    await interaction.editReply(`Failed to create channel: ${err.message}`);
+                }
+                break;
+            }
         }
     }
     async handleCronsCommand(interaction, channelId) {
@@ -727,6 +789,37 @@ export class CcDiscordBot {
             }
         })();
     }
+    /**
+     * Create a new Discord text channel for `namespace`, register it in channelNamespaceMap,
+     * and start the meta-agent for `repoUrl`. Fire-and-forget after sending the confirmation message.
+     */
+    async createChannelForRepo(msg, namespace, repoUrl) {
+        const channel = msg.channel;
+        const guild = msg.guild;
+        if (!guild) {
+            await channel.send("Channel creation requires a guild (not available in DMs).").catch(() => { });
+            return;
+        }
+        let newChannel;
+        try {
+            newChannel = await guild.channels.create({ name: namespace, type: ChannelType.GuildText });
+        }
+        catch (err) {
+            await channel.send(`Failed to create channel: ${err.message}`).catch(() => { });
+            return;
+        }
+        this.channelNamespaceMap.set(newChannel.id, { namespace, repoUrl });
+        this.opts.registerRoutedChannelId?.(namespace, newChannel.id);
+        await channel.send(`Created <#${newChannel.id}> — messages there route to the ${repoUrl} meta-agent`).catch(() => { });
+        // Start meta-agent in the background after acknowledging the user
+        if (this.redis) {
+            ensureMetaAgent(namespace, repoUrl, (toolName, args) => this.callCcAgentTool(toolName, args ?? {}), this.redis)
+                .catch((err) => {
+                console.error(`[bot] ensureMetaAgent(${namespace}) failed:`, err.message);
+                this.sendToChannelById(newChannel.id, `Warning: meta-agent startup failed — ${err.message}`).catch(() => { });
+            });
+        }
+    }
     /** Write a message to the Redis chat log. Fire-and-forget. */
     writeChatMessage(role, source, content, channelId) {
         if (!this.redis)

package/dist/router.d.ts

@@ -1,5 +1,5 @@
 /**
- * Hashtag meta-agent routing.
+ * Routing helpers: hashtag meta-agent routing and channel-creation intent detection.
  *
  * Parses #tag or #org/repo tokens from Telegram messages and routes them to
  * the appropriate cc-agent meta-agent instead of the local Claude session.
@@ -50,6 +50,19 @@ export declare function parseRoutingTag(text: string): RoutingTag | null;
  * Throws on failure (repo creation error, tool call failure, or timeout).
  */
 export declare function ensureMetaAgent(namespace: string, repoUrl: string, callTool: CallToolFn, redis: Redis): Promise<void>;
+/**
+ * Detect a natural-language channel-creation request.
+ * Matches:
+ *   "channel for https://github.com/org/repo"
+ *   "create channel for https://github.com/org/repo"
+ *   "add channel for https://github.com/org/repo"
+ *
+ * Returns { namespace, repoUrl } or null.
+ */
+export declare function parseChannelCreateIntent(text: string): {
+    namespace: string;
+    repoUrl: string;
+} | null;
 /**
  * Route a message to a running meta-agent via Redis RPUSH.
  * The cc-agent polls cca:meta:{namespace}:input every 3s (up to 3s delivery latency).

package/dist/router.js

@@ -1,5 +1,5 @@
 /**
- * Hashtag meta-agent routing.
+ * Routing helpers: hashtag meta-agent routing and channel-creation intent detection.
  *
  * Parses #tag or #org/repo tokens from Telegram messages and routes them to
  * the appropriate cc-agent meta-agent instead of the local Claude session.
@@ -173,6 +173,23 @@ export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
     }
     throw new Error(`Meta-agent for ${namespace} did not become ready within ${timeoutMs}ms`);
 }
+/**
+ * Detect a natural-language channel-creation request.
+ * Matches:
+ *   "channel for https://github.com/org/repo"
+ *   "create channel for https://github.com/org/repo"
+ *   "add channel for https://github.com/org/repo"
+ *
+ * Returns { namespace, repoUrl } or null.
+ */
+export function parseChannelCreateIntent(text) {
+    const match = text.match(/(?:create\s+|add\s+)?channel\s+for\s+(https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+))/i);
+    if (!match)
+        return null;
+    const repoUrl = match[1];
+    const namespace = match[3];
+    return { namespace, repoUrl };
+}
 /**
  * Route a message to a running meta-agent via Redis RPUSH.
  * The cc-agent polls cca:meta:{namespace}:input every 3s (up to 3s delivery latency).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {