comisai 1.0.19 → 1.0.23

package/node_modules/@comis/channels/dist/shared/thinking-tag-filter.js

@@ -1,206 +0,0 @@
-/**
- * Thinking tag filter -- strips <think>, <thinking>, and <final> blocks
- * from streaming deltas using a character-level state machine.
- *
- * Handles tags split across chunk boundaries by buffering partial
- * tag sequences and resolving them when more data arrives.
- *
- * @module
- */
-/** Recognized thinking tag names (lowercased).
- * Note: "final" is NOT included — <final> wraps the actual answer content
- * and should be unwrapped (tags stripped, content kept), not suppressed.
- * See sanitizeAssistantResponse() in @comis/agent sanitize-pipeline.ts. */
-const THINKING_TAGS = new Set(["think", "thinking"]);
-/** Maximum buffer length before we give up matching a tag. */
-const MAX_BUFFER = 24;
-/**
- * Create a thinking tag filter that strips thinking blocks from streaming deltas.
- *
- * The filter processes characters one at a time through a state machine:
- * - `passthrough`: Normal text flows through. On `<`, transition to `buffering`.
- * - `buffering`: Accumulating chars after `<` to identify an opening or closing tag.
- * - `inside_block`: All text is suppressed. On `<`, transition to `close_buffering`.
- * - `close_buffering`: Inside a block, checking for the matching closing tag.
- */
-export function createThinkingTagFilter() {
-    let state = "passthrough";
-    let buffer = "";
-    let activeTag = ""; // The tag name that opened the current block (lowercased)
-    /**
-     * Try to resolve the buffer as a tag.
-     *
-     * Returns:
-     * - `{ type: "open", tagName }` if buffer is a complete opening tag like `<think>`
-     * - `{ type: "close", tagName }` if buffer is a complete closing tag like `</think>`
-     * - `{ type: "not_tag" }` if buffer cannot be a thinking tag (flush as text)
-     * - `{ type: "partial" }` if buffer could still become a thinking tag (keep buffering)
-     */
-    function classifyBuffer(buf) {
-        // Buffer must start with <
-        if (!buf.startsWith("<"))
-            return { type: "not_tag" };
-        const lower = buf.toLowerCase();
-        // Check for closing tag pattern: </tagname>
-        if (lower.length >= 2 && lower[1] === "/") {
-            const rest = lower.slice(2);
-            // Check if it ends with >
-            if (rest.endsWith(">")) {
-                const tagName = rest.slice(0, -1);
-                if (THINKING_TAGS.has(tagName)) {
-                    return { type: "close", tagName };
-                }
-                return { type: "not_tag" };
-            }
-            // Still could be partial: check if any thinking tag starts with what we have
-            for (const tag of THINKING_TAGS) {
-                if (tag.startsWith(rest) || rest.startsWith(tag)) {
-                    return { type: "partial" };
-                }
-            }
-            return { type: "not_tag" };
-        }
-        // Check for opening tag pattern: <tagname> or <tagname/>
-        const rest = lower.slice(1);
-        // If it ends with ">", check the tag name
-        if (rest.endsWith(">")) {
-            // Could be <tagname> or <tagname/>
-            let tagName = rest.slice(0, -1);
-            if (tagName.endsWith("/")) {
-                tagName = tagName.slice(0, -1);
-            }
-            if (THINKING_TAGS.has(tagName)) {
-                return { type: "open", tagName };
-            }
-            return { type: "not_tag" };
-        }
-        // Still accumulating -- check if any thinking tag could match
-        for (const tag of THINKING_TAGS) {
-            // rest could be a prefix of the tag name (e.g., "thi" prefix of "think")
-            if (tag.startsWith(rest)) {
-                return { type: "partial" };
-            }
-            // rest could be the tag name followed by "/" (self-closing start)
-            if (rest.startsWith(tag) && (rest.length === tag.length || rest[tag.length] === "/")) {
-                return { type: "partial" };
-            }
-        }
-        return { type: "not_tag" };
-    }
-    function processChar(ch, output) {
-        switch (state) {
-            case "passthrough":
-                if (ch === "<") {
-                    buffer = "<";
-                    state = "buffering";
-                }
-                else {
-                    output.push(ch);
-                }
-                break;
-            case "buffering":
-                buffer += ch;
-                // Safety limit
-                if (buffer.length > MAX_BUFFER) {
-                    output.push(buffer);
-                    buffer = "";
-                    state = "passthrough";
-                    break;
-                }
-                {
-                    const result = classifyBuffer(buffer);
-                    if (result.type === "open") {
-                        // Enter inside_block, suppress everything
-                        activeTag = result.tagName;
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "close") {
-                        // Closing tag outside a block -- just flush it as text
-                        output.push(buffer);
-                        buffer = "";
-                        state = "passthrough";
-                    }
-                    else if (result.type === "not_tag") {
-                        // Not a thinking tag -- flush buffer as normal text
-                        output.push(buffer);
-                        buffer = "";
-                        state = "passthrough";
-                    }
-                    // "partial" -- keep buffering
-                }
-                break;
-            case "inside_block":
-                if (ch === "<") {
-                    buffer = "<";
-                    state = "close_buffering";
-                }
-                // else: suppress character
-                break;
-            case "close_buffering":
-                buffer += ch;
-                // Safety limit
-                if (buffer.length > MAX_BUFFER) {
-                    // Not a closing tag -- stay inside block
-                    buffer = "";
-                    state = "inside_block";
-                    break;
-                }
-                {
-                    const result = classifyBuffer(buffer);
-                    if (result.type === "close" && result.tagName === activeTag) {
-                        // Matching closing tag found -- exit block
-                        buffer = "";
-                        activeTag = "";
-                        state = "passthrough";
-                    }
-                    else if (result.type === "close") {
-                        // Non-matching closing tag -- stay inside block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "open") {
-                        // Nested opening tag inside block -- just suppress, stay in block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    else if (result.type === "not_tag") {
-                        // Not a tag at all -- suppress it, stay in block
-                        buffer = "";
-                        state = "inside_block";
-                    }
-                    // "partial" -- keep buffering
-                }
-                break;
-        }
-    }
-    return {
-        feed(delta) {
-            const output = [];
-            for (let i = 0; i < delta.length; i++) {
-                processChar(delta[i], output);
-            }
-            return output.join("");
-        },
-        flush() {
-            // Return any buffered text that never resolved to a thinking tag
-            if (buffer && (state === "buffering")) {
-                const result = buffer;
-                buffer = "";
-                state = "passthrough";
-                return result;
-            }
-            // If inside a block or close_buffering, the block was never closed.
-            // Discard -- thinking content should not leak to output.
-            buffer = "";
-            state = "passthrough";
-            activeTag = "";
-            return "";
-        },
-        reset() {
-            state = "passthrough";
-            buffer = "";
-            activeTag = "";
-        },
-    };
-}

package/node_modules/@comis/cli/dist/wizard/config-writer.d.ts

@@ -1,25 +0,0 @@
-/**
- * Config writer for wizard results.
- *
- * Converts WizardResult into a valid config.yaml and .env file
- * using the yaml library's stringify (not hand-rolled YAML).
- * Uses safePath from @comis/core for all file write paths.
- *
- * @module
- */
-import { type Result } from "@comis/shared";
-import type { WizardResult } from "./flow-types.js";
-/**
- * Write a config.yaml file from wizard results.
- *
- * Builds a config object matching AppConfigSchema shape and serializes
- * it to YAML via the yaml library. Returns the written file path.
- */
-export declare function writeWizardConfig(result: WizardResult, configDir: string): Result<string, Error>;
-/**
- * Write a .env file from wizard results.
- *
- * Sets the appropriate provider API key environment variable.
- * File is written with mode 0o600 (owner read/write only).
- */
-export declare function writeWizardEnv(result: WizardResult, configDir: string): Result<string, Error>;

package/node_modules/@comis/cli/dist/wizard/config-writer.js

@@ -1,144 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Config writer for wizard results.
- *
- * Converts WizardResult into a valid config.yaml and .env file
- * using the yaml library's stringify (not hand-rolled YAML).
- * Uses safePath from @comis/core for all file write paths.
- *
- * @module
- */
-import * as fs from "node:fs";
-import * as os from "node:os";
-import { stringify } from "yaml";
-import { safePath } from "@comis/core";
-import { ok, err } from "@comis/shared";
-import { PROVIDER_ENV_KEYS, CHANNEL_ENV_KEYS } from "./flow-types.js";
-/**
- * Write a config.yaml file from wizard results.
- *
- * Builds a config object matching AppConfigSchema shape and serializes
- * it to YAML via the yaml library. Returns the written file path.
- */
-export function writeWizardConfig(result, configDir) {
-    try {
-        const defaultDir = os.homedir() + "/.comis";
-        const config = {
-            logLevel: "info",
-            dataDir: result.dataDir ?? defaultDir,
-            agents: {
-                default: {
-                    name: result.agentName,
-                    provider: result.provider,
-                    model: result.model ?? getDefaultModel(result.provider),
-                },
-            },
-        };
-        // Gateway section
-        const gatewayConfig = {
-            enabled: result.gatewayEnabled ?? false,
-        };
-        if (result.gatewayEnabled) {
-            gatewayConfig.host = result.gatewayHost ?? "127.0.0.1";
-            gatewayConfig.port = result.gatewayPort ?? 3000;
-            if (result.gatewayToken) {
-                gatewayConfig.tokens = [
-                    { id: "default", secret: "${COMIS_GATEWAY_TOKEN}", scopes: ["*"] },
-                ];
-            }
-        }
-        config.gateway = gatewayConfig;
-        // Channels section
-        if (result.channels && result.channels.length > 0) {
-            const channels = {};
-            for (const ch of result.channels) {
-                const entry = { enabled: true };
-                // Use ${VAR} substitution — credentials go in .env, not config.yaml
-                if (ch.type === "telegram" && ch.botToken)
-                    entry.botToken = "${TELEGRAM_BOT_TOKEN}";
-                if (ch.type === "discord" && ch.botToken)
-                    entry.botToken = "${DISCORD_BOT_TOKEN}";
-                if (ch.type === "slack" && ch.botToken)
-                    entry.botToken = "${SLACK_BOT_TOKEN}";
-                if (ch.type === "slack" && ch.apiKey)
-                    entry.signingSecret = "${SLACK_SIGNING_SECRET}";
-                if (ch.type === "whatsapp" && ch.botToken)
-                    entry.accessToken = "${WHATSAPP_ACCESS_TOKEN}";
-                if (ch.type === "line" && ch.botToken)
-                    entry.channelAccessToken = "${LINE_CHANNEL_ACCESS_TOKEN}";
-                if (ch.type === "line" && ch.apiKey)
-                    entry.channelSecret = "${LINE_CHANNEL_SECRET}";
-                // Generic fallback for other channel types
-                if (ch.botToken && !entry.botToken && !entry.accessToken && !entry.channelAccessToken) {
-                    entry.botToken = `\${${ch.type.toUpperCase()}_BOT_TOKEN}`;
-                }
-                if (ch.apiKey && !entry.signingSecret && !entry.channelSecret) {
-                    entry.apiKey = `\${${ch.type.toUpperCase()}_API_KEY}`;
-                }
-                if (ch.appToken)
-                    entry.appToken = `\${${ch.type.toUpperCase()}_APP_TOKEN}`;
-                channels[ch.type] = entry;
-            }
-            config.channels = channels;
-        }
-        const yaml = stringify(config, { lineWidth: 0 });
-        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-        const configPath = safePath(configDir, "config.yaml");
-        fs.writeFileSync(configPath, yaml, "utf-8");
-        return ok(configPath);
-    }
-    catch (e) {
-        return err(e instanceof Error ? e : new Error(String(e)));
-    }
-}
-/**
- * Write a .env file from wizard results.
- *
- * Sets the appropriate provider API key environment variable.
- * File is written with mode 0o600 (owner read/write only).
- */
-export function writeWizardEnv(result, configDir) {
-    try {
-        const lines = ["# Comis secrets -- generated by init wizard"];
-        if (result.provider && result.apiKey) {
-            const envKey = PROVIDER_ENV_KEYS[result.provider];
-            if (envKey) {
-                lines.push(`${envKey}=${result.apiKey}`);
-            }
-        }
-        // Write channel credentials to .env
-        if (result.channels) {
-            for (const ch of result.channels) {
-                const envKeys = CHANNEL_ENV_KEYS[ch.type];
-                if (ch.botToken && envKeys?.[0])
-                    lines.push(`${envKeys[0]}=${ch.botToken}`);
-                if (ch.apiKey && envKeys?.[1])
-                    lines.push(`${envKeys[1]}=${ch.apiKey}`);
-                if (ch.appToken)
-                    lines.push(`${ch.type.toUpperCase()}_APP_TOKEN=${ch.appToken}`);
-            }
-        }
-        // Write gateway token to .env
-        if (result.gatewayToken) {
-            lines.push(`COMIS_GATEWAY_TOKEN=${result.gatewayToken}`);
-        }
-        fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
-        const envPath = safePath(configDir, ".env");
-        fs.writeFileSync(envPath, lines.join("\n") + "\n", { mode: 0o600 });
-        return ok(envPath);
-    }
-    catch (e) {
-        return err(e instanceof Error ? e : new Error(String(e)));
-    }
-}
-/** Get a sensible default model for a provider. */
-function getDefaultModel(provider) {
-    const defaults = {
-        anthropic: "claude-sonnet-4-5-20250929",
-        openai: "gpt-4o",
-        google: "gemini-2.0-flash",
-        groq: "llama-3.3-70b-versatile",
-        ollama: "llama3",
-    };
-    return defaults[provider] ?? "default";
-}

package/node_modules/@comis/cli/dist/wizard/flow-types.d.ts

@@ -1,48 +0,0 @@
-/**
- * Shared types and constants for the init wizard flows.
- *
- * Provides the WizardResult, ChannelSetup, and ProviderChoice types
- * used by both QuickStart and Manual flows, plus constant arrays
- * for providers, channel types, and minimum key lengths.
- *
- * @module
- */
-/** Result collected from any wizard flow. */
-export interface WizardResult {
-    provider: string;
-    agentName: string;
-    apiKey?: string;
-    model?: string;
-    channels?: ChannelSetup[];
-    gatewayEnabled?: boolean;
-    gatewayHost?: string;
-    gatewayPort?: number;
-    gatewayToken?: string;
-    dataDir?: string;
-}
-/** Channel configuration collected during the wizard. */
-export interface ChannelSetup {
-    type: "telegram" | "discord" | "slack" | "whatsapp" | "signal" | "irc" | "line";
-    botToken?: string;
-    apiKey?: string;
-    appToken?: string;
-}
-/** A provider option for Clack select prompts. */
-export interface ProviderChoice {
-    value: string;
-    label: string;
-    hint?: string;
-}
-/** Provider options for Clack select prompts. */
-export declare const PROVIDERS: ProviderChoice[];
-/** Minimum API key lengths per provider (0 = no key needed). */
-export declare const MIN_KEY_LENGTHS: Record<string, number>;
-/** Map provider name to the environment variable key for the API key. */
-export declare const PROVIDER_ENV_KEYS: Record<string, string>;
-/** Map channel type to required credential environment variable names. */
-export declare const CHANNEL_ENV_KEYS: Record<string, string[]>;
-/** All supported channel types for Clack multiselect. */
-export declare const CHANNEL_TYPES: {
-    value: ChannelSetup["type"];
-    label: string;
-}[];

package/node_modules/@comis/cli/dist/wizard/flow-types.js

@@ -1,70 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Shared types and constants for the init wizard flows.
- *
- * Provides the WizardResult, ChannelSetup, and ProviderChoice types
- * used by both QuickStart and Manual flows, plus constant arrays
- * for providers, channel types, and minimum key lengths.
- *
- * @module
- */
-// ---------- Constants ----------
-/** Provider options for Clack select prompts. */
-export const PROVIDERS = [
-    { value: "anthropic", label: "Anthropic (Claude)", hint: "Recommended" },
-    { value: "openai", label: "OpenAI (GPT)" },
-    { value: "google", label: "Google (Gemini)" },
-    { value: "groq", label: "Groq", hint: "Fast inference" },
-    { value: "mistral", label: "Mistral" },
-    { value: "deepseek", label: "DeepSeek" },
-    { value: "xai", label: "xAI (Grok)" },
-    { value: "together", label: "Together AI" },
-    { value: "cerebras", label: "Cerebras", hint: "Fast inference" },
-    { value: "openrouter", label: "OpenRouter", hint: "Multi-provider gateway" },
-    { value: "ollama", label: "Ollama (local)", hint: "No API key needed" },
-];
-/** Minimum API key lengths per provider (0 = no key needed). */
-export const MIN_KEY_LENGTHS = {
-    anthropic: 20,
-    openai: 20,
-    google: 20,
-    groq: 20,
-    mistral: 20,
-    deepseek: 20,
-    xai: 20,
-    together: 20,
-    cerebras: 20,
-    openrouter: 20,
-    ollama: 0,
-};
-/** Map provider name to the environment variable key for the API key. */
-export const PROVIDER_ENV_KEYS = {
-    anthropic: "ANTHROPIC_API_KEY",
-    openai: "OPENAI_API_KEY",
-    google: "GOOGLE_API_KEY",
-    groq: "GROQ_API_KEY",
-    mistral: "MISTRAL_API_KEY",
-    deepseek: "DEEPSEEK_API_KEY",
-    xai: "XAI_API_KEY",
-    together: "TOGETHER_API_KEY",
-    cerebras: "CEREBRAS_API_KEY",
-    openrouter: "OPENROUTER_API_KEY",
-};
-/** Map channel type to required credential environment variable names. */
-export const CHANNEL_ENV_KEYS = {
-    telegram: ["TELEGRAM_BOT_TOKEN"],
-    discord: ["DISCORD_BOT_TOKEN"],
-    slack: ["SLACK_BOT_TOKEN", "SLACK_SIGNING_SECRET"],
-    whatsapp: ["WHATSAPP_ACCESS_TOKEN", "WHATSAPP_VERIFY_TOKEN"],
-    line: ["LINE_CHANNEL_ACCESS_TOKEN", "LINE_CHANNEL_SECRET"],
-};
-/** All supported channel types for Clack multiselect. */
-export const CHANNEL_TYPES = [
-    { value: "telegram", label: "Telegram" },
-    { value: "discord", label: "Discord" },
-    { value: "slack", label: "Slack" },
-    { value: "whatsapp", label: "WhatsApp" },
-    { value: "signal", label: "Signal" },
-    { value: "irc", label: "IRC" },
-    { value: "line", label: "LINE" },
-];

package/node_modules/@comis/cli/dist/wizard/manual-flow.d.ts

@@ -1,21 +0,0 @@
-/**
- * Manual wizard flow.
- *
- * Full-control wizard covering all 8 steps: provider, API key,
- * agent name, model, channels, gateway, data directory, and review.
- * Uses ModelCatalog from @comis/agent for dynamic model selection.
- *
- * @module
- */
-import { type Result } from "@comis/shared";
-import type { WizardResult } from "./flow-types.js";
-/**
- * Run the Manual wizard flow.
- *
- * Presents all configuration options: provider, API key, agent name,
- * model, channels, gateway, data directory, and a review step.
- *
- * @param configDir - Override config directory (default ~/.comis)
- * @returns The wizard result or an error
- */
-export declare function runManualFlow(configDir?: string): Promise<Result<WizardResult, Error>>;