profclaw 0.0.1-beta.1

package/dist/chat/prompt-adapter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Model-Adaptive Prompt System
+ *
+ * Adapts system prompts based on model capability:
+ * - Reasoning models (Claude, GPT-4): high-level goals, natural language
+ * - Instruction models (GPT-3.5, Haiku): step-by-step instructions
+ * - Basic models (Llama 7B, Phi): explicit fill-in-the-blank, strict format
+ *
+ * Also handles:
+ * - Context budget awareness (auto-truncate based on context window)
+ * - Few-shot examples for small models
+ * - Tool usage instructions adapted per level
+ */
+export type ModelCapabilityLevel = 'reasoning' | 'instruction' | 'basic';
+export interface AdaptPromptOptions {
+    modelId: string;
+    systemPrompt: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+    contextWindowSize?: number;
+    toolDescriptions?: string;
+}
+export interface AdaptedPrompt {
+    systemPrompt: string;
+    truncatedHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+    adaptationLevel: ModelCapabilityLevel;
+    estimatedTokens: number;
+}
+/**
+ * Classify a model's capability level based on its ID
+ */
+export declare function classifyModelCapability(modelId: string): ModelCapabilityLevel;
+/**
+ * Adapt a system prompt for a specific model's capability level.
+ * Adds appropriate prefixes, guidance, and truncates history to fit context budget.
+ */
+export declare function adaptPromptForModel(options: AdaptPromptOptions): AdaptedPrompt;
+/**
+ * Get adaptation info for display purposes (e.g. in debug UI or session status)
+ */
+export declare function getAdaptationInfo(modelId: string): {
+    level: ModelCapabilityLevel;
+    description: string;
+    maxTools: string;
+    historyBudget: string;
+};
+//# sourceMappingURL=prompt-adapter.d.ts.map

package/dist/chat/prompt-adapter.js

@@ -0,0 +1,245 @@
+/**
+ * Model-Adaptive Prompt System
+ *
+ * Adapts system prompts based on model capability:
+ * - Reasoning models (Claude, GPT-4): high-level goals, natural language
+ * - Instruction models (GPT-3.5, Haiku): step-by-step instructions
+ * - Basic models (Llama 7B, Phi): explicit fill-in-the-blank, strict format
+ *
+ * Also handles:
+ * - Context budget awareness (auto-truncate based on context window)
+ * - Few-shot examples for small models
+ * - Tool usage instructions adapted per level
+ */
+import { logger } from '../utils/logger.js';
+// --- Model Classification ---
+const REASONING_PATTERNS = [
+    /claude-(3\.5|4|opus|sonnet-4)/i,
+    /gpt-4o|gpt-4-turbo|gpt-4\.5/i,
+    /gemini-(pro|1\.5|2\.0)/i,
+    /o[13]-/i,
+    /deepseek-(v3|r1|chat)/i,
+    /qwen-?2\.5-(72b|110b)/i,
+    /llama-?3\.1-405b/i,
+];
+const INSTRUCTION_PATTERNS = [
+    /claude.*haiku/i,
+    /gpt-3\.5/i,
+    /gemini.*flash/i,
+    /mistral-(large|medium)/i,
+    /llama-?3\.(1-70b|3-70b)/i,
+    /qwen-?2\.5-(32b|14b)/i,
+    /command-r/i,
+    /mixtral/i,
+];
+// Everything else defaults to 'basic'
+/**
+ * Classify a model's capability level based on its ID
+ */
+export function classifyModelCapability(modelId) {
+    if (REASONING_PATTERNS.some((p) => p.test(modelId)))
+        return 'reasoning';
+    if (INSTRUCTION_PATTERNS.some((p) => p.test(modelId)))
+        return 'instruction';
+    // Check for size indicator in model ID (e.g. "llama-13b", "phi-7b")
+    const sizeMatch = modelId.match(/(\d+)b$/i);
+    if (sizeMatch) {
+        const size = parseInt(sizeMatch[1], 10);
+        if (size >= 70)
+            return 'instruction';
+        if (size >= 30)
+            return 'instruction';
+    }
+    // Unknown - default to instruction (safe middle ground)
+    return 'instruction';
+}
+/**
+ * Get estimated context window size for a model
+ */
+function getContextWindow(modelId) {
+    if (/claude|gpt-4o|gemini-(1\.5|2)/i.test(modelId))
+        return 128000;
+    if (/gpt-4-turbo/i.test(modelId))
+        return 128000;
+    if (/gpt-3\.5/i.test(modelId))
+        return 16385;
+    if (/llama-?3/i.test(modelId))
+        return 131072;
+    if (/qwen/i.test(modelId))
+        return 32768;
+    if (/mistral/i.test(modelId))
+        return 32768;
+    if (/phi/i.test(modelId))
+        return 16384;
+    if (/gemma/i.test(modelId))
+        return 8192;
+    return 32768;
+}
+// --- Prompt Adaptations ---
+const ADAPTATIONS = {
+    reasoning: {
+        // No prefix needed - these models understand natural language well
+        systemPromptPrefix: '',
+        toolUsageGuidance: `Use the available tools as needed to accomplish the user's request. Choose the most appropriate tool for each step.`,
+        // Natural language response is fine
+        responseFormat: '',
+        // Can handle long history
+        maxHistoryTokens: 100000,
+        // Not needed for reasoning models
+        fewShotExamples: [],
+    },
+    instruction: {
+        systemPromptPrefix: `IMPORTANT: Follow these instructions carefully. Complete each step in order.\n\n`,
+        toolUsageGuidance: `When using tools:
+1. Read the tool description carefully before using it
+2. Provide all required parameters
+3. Check the result before proceeding to the next step
+4. If a tool fails, explain the error to the user`,
+        responseFormat: `Format your responses clearly with markdown. Use bullet points for lists.`,
+        // More limited context budget
+        maxHistoryTokens: 12000,
+        fewShotExamples: [
+            `User: "Read the file config.json"
+Assistant: I'll read that file for you.
+[Uses read_file tool with path="config.json"]
+Here's the content of config.json: ...`,
+        ],
+    },
+    basic: {
+        systemPromptPrefix: `You are a helpful assistant with access to tools. Follow these rules EXACTLY:
+1. Answer the user's question directly
+2. Use ONLY the tools listed below when needed
+3. Do NOT make up tool names - use only what is available
+4. Keep responses short and clear\n\n`,
+        toolUsageGuidance: `TOOL USAGE RULES:
+- Use tools ONLY when the user asks you to do something (read files, search, execute commands)
+- Do NOT use tools just to answer simple questions
+- When using a tool, provide ALL required parameters exactly
+- After using a tool, summarize the result in 1-2 sentences`,
+        responseFormat: `RESPONSE FORMAT:
+- Keep responses under 200 words unless the user asks for detail
+- Use simple language
+- Do NOT use complex markdown formatting
+- Answer the question first, then explain if needed`,
+        // Very limited context budget
+        maxHistoryTokens: 4000,
+        fewShotExamples: [
+            `User: "What's in the src folder?"
+Assistant: I'll list the files in src/ for you.
+[Uses search_files with directory="src", pattern="*"]
+The src/ folder contains: index.ts, server.ts, types.ts, and folders: chat/, routes/, providers/.`,
+            `User: "Run the tests"
+Assistant: Running tests now.
+[Uses exec with command="pnpm test"]
+Tests completed: 45 passed, 0 failed.`,
+        ],
+    },
+};
+// --- Core Function ---
+/**
+ * Adapt a system prompt for a specific model's capability level.
+ * Adds appropriate prefixes, guidance, and truncates history to fit context budget.
+ */
+export function adaptPromptForModel(options) {
+    const level = classifyModelCapability(options.modelId);
+    const adaptation = ADAPTATIONS[level];
+    const contextWindow = options.contextWindowSize ?? getContextWindow(options.modelId);
+    // Suppress unused variable warning - contextWindow reserved for future budget checks
+    void contextWindow;
+    // Build adapted system prompt
+    const parts = [];
+    // Prefix for instruction/basic models
+    if (adaptation.systemPromptPrefix) {
+        parts.push(adaptation.systemPromptPrefix);
+    }
+    // Original system prompt
+    parts.push(options.systemPrompt);
+    // Tool usage guidance (only when tools are available)
+    if (options.toolDescriptions) {
+        parts.push('\n\n' + adaptation.toolUsageGuidance);
+    }
+    // Response format guidance for non-reasoning models
+    if (adaptation.responseFormat) {
+        parts.push('\n\n' + adaptation.responseFormat);
+    }
+    // Few-shot examples for basic models
+    if (adaptation.fewShotExamples.length > 0) {
+        parts.push('\n\n## Examples\n');
+        for (const example of adaptation.fewShotExamples) {
+            parts.push(example);
+            parts.push('');
+        }
+    }
+    const adaptedPrompt = parts.join('\n');
+    // Truncate conversation history based on context budget
+    let truncatedHistory = options.conversationHistory;
+    if (truncatedHistory && truncatedHistory.length > 0) {
+        truncatedHistory = truncateHistory(truncatedHistory, adaptation.maxHistoryTokens);
+    }
+    const estimatedTokens = estimateTokenCount(adaptedPrompt);
+    logger.debug('[PromptAdapter] Adapted prompt', {
+        model: options.modelId,
+        level,
+        originalLength: options.systemPrompt.length,
+        adaptedLength: adaptedPrompt.length,
+        estimatedTokens,
+        historyMessages: truncatedHistory?.length ?? 0,
+    });
+    return {
+        systemPrompt: adaptedPrompt,
+        truncatedHistory,
+        adaptationLevel: level,
+        estimatedTokens,
+    };
+}
+/**
+ * Truncate conversation history to fit within token budget.
+ * Always preserves the first message (task context), then keeps most recent messages.
+ */
+function truncateHistory(history, maxTokens) {
+    if (history.length <= 2)
+        return history;
+    let totalTokens = 0;
+    const result = [];
+    // Always keep first message (usually contains task context)
+    result.push(history[0]);
+    totalTokens += estimateTokenCount(history[0].content);
+    // Add messages from the end (most recent) until budget is exhausted
+    const remaining = history.slice(1);
+    const reversed = [...remaining].reverse();
+    const toAdd = [];
+    for (const msg of reversed) {
+        const msgTokens = estimateTokenCount(msg.content);
+        if (totalTokens + msgTokens > maxTokens)
+            break;
+        totalTokens += msgTokens;
+        toAdd.unshift(msg);
+    }
+    result.push(...toAdd);
+    return result;
+}
+/**
+ * Rough token count estimate (1 token ~= 4 chars for English text)
+ */
+function estimateTokenCount(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Get adaptation info for display purposes (e.g. in debug UI or session status)
+ */
+export function getAdaptationInfo(modelId) {
+    const level = classifyModelCapability(modelId);
+    const adaptation = ADAPTATIONS[level];
+    const descriptions = {
+        reasoning: 'Full capability - natural language, all tools, long context',
+        instruction: 'Instruction-following - step-by-step guidance, standard tools',
+        basic: 'Basic - explicit rules, essential tools only, short context',
+    };
+    return {
+        level,
+        description: descriptions[level],
+        maxTools: level === 'basic' ? '8-10' : level === 'instruction' ? '25-30' : 'all',
+        historyBudget: `~${adaptation.maxHistoryTokens} tokens`,
+    };
+}
+//# sourceMappingURL=prompt-adapter.js.map

package/dist/chat/providers/dingtalk/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * DingTalk Provider - webhook-based robot integration.
+ * Outbound: POST text to robot webhook URL (optional HMAC-SHA256 signing).
+ * Inbound: parse callback payloads for direct and group messages.
+ * API base: https://oapi.dingtalk.com
+ */
+import { z } from 'zod';
+import type { ChatProvider, DingTalkAccountConfig } from '../types.js';
+declare const DingTalkMsgType: {
+    readonly TEXT: "text";
+    readonly IMAGE: "image";
+    readonly AUDIO: "audio";
+    readonly VIDEO: "video";
+    readonly FILE: "file";
+};
+type DingTalkMsgTypeValue = (typeof DingTalkMsgType)[keyof typeof DingTalkMsgType];
+interface DingTalkInboundPayload {
+    msgtype: DingTalkMsgTypeValue;
+    text?: {
+        content: string;
+    };
+    msgId?: string;
+    senderNick: string;
+    senderId: string;
+    conversationType: '1' | '2';
+    conversationId: string;
+    conversationTitle?: string;
+}
+export declare const DingTalkAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"dingtalk">;
+    appKey: z.ZodOptional<z.ZodString>;
+    appSecret: z.ZodOptional<z.ZodString>;
+    robotCode: z.ZodOptional<z.ZodString>;
+    webhookUrl: z.ZodOptional<z.ZodString>;
+    webhookSecret: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "dingtalk";
+    enabled: boolean;
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    webhookSecret?: string | undefined;
+    webhookUrl?: string | undefined;
+    appSecret?: string | undefined;
+    appKey?: string | undefined;
+    robotCode?: string | undefined;
+}, {
+    id: string;
+    provider: "dingtalk";
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    enabled?: boolean | undefined;
+    webhookSecret?: string | undefined;
+    webhookUrl?: string | undefined;
+    appSecret?: string | undefined;
+    appKey?: string | undefined;
+    robotCode?: string | undefined;
+}>;
+type DingTalkConfig = z.infer<typeof DingTalkAccountConfigSchema>;
+export declare function setDingTalkConfig(config: DingTalkConfig): void;
+export declare function clearDingTalkConfig(): void;
+export declare const dingtalkProvider: ChatProvider<DingTalkAccountConfig>;
+export type { DingTalkConfig, DingTalkInboundPayload };
+export { DingTalkMsgType };
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/providers/dingtalk/index.js

@@ -0,0 +1,225 @@
+/**
+ * DingTalk Provider - webhook-based robot integration.
+ * Outbound: POST text to robot webhook URL (optional HMAC-SHA256 signing).
+ * Inbound: parse callback payloads for direct and group messages.
+ * API base: https://oapi.dingtalk.com
+ */
+import { createHmac } from 'node:crypto';
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- types ---
+const DingTalkMsgType = {
+    TEXT: 'text',
+    IMAGE: 'image',
+    AUDIO: 'audio',
+    VIDEO: 'video',
+    FILE: 'file',
+};
+// --- config ---
+export const DingTalkAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('dingtalk'),
+    appKey: z.string().optional(),
+    appSecret: z.string().optional(),
+    robotCode: z.string().optional(),
+    webhookUrl: z.string().url().optional(),
+    webhookSecret: z.string().optional(),
+});
+// --- metadata ---
+const meta = {
+    id: 'dingtalk',
+    name: 'DingTalk',
+    description: 'DingTalk robot webhook integration for direct and group chat',
+    icon: 'DingTalk icon',
+    docsUrl: 'https://open.dingtalk.com/document/robots/custom-robot-access',
+    order: 13,
+    color: '#0089FF',
+};
+const capabilities = {
+    chatTypes: ['direct', 'group'],
+    send: true,
+    receive: true,
+    slashCommands: false,
+    interactiveComponents: false,
+    reactions: false,
+    edit: false,
+    delete: false,
+    threads: false,
+    media: true,
+    richBlocks: false,
+    oauth: false,
+    webhooks: true,
+    realtime: false,
+};
+// --- state and helpers ---
+let currentConfig = null;
+function buildSignedUrl(webhookUrl, secret) {
+    const timestamp = Date.now();
+    const sign = encodeURIComponent(createHmac('sha256', secret).update(`${timestamp}\n${secret}`, 'utf8').digest('base64'));
+    return `${webhookUrl}&timestamp=${timestamp}&sign=${sign}`;
+}
+async function postWebhook(webhookUrl, body, secret) {
+    const url = secret ? buildSignedUrl(webhookUrl, secret) : webhookUrl;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = await response.json();
+        if (data.errcode !== 0) {
+            logger.warn('[DingTalk] Webhook error:', { errcode: data.errcode, errmsg: data.errmsg });
+            return { ok: false, error: `DingTalk error ${data.errcode}: ${data.errmsg}` };
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        logger.error('[DingTalk] Webhook call failed:', error instanceof Error ? error : undefined);
+        return { ok: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+// --- auth adapter ---
+const authAdapter = {
+    getAuthUrl(_state, _scopes) {
+        throw new Error('DingTalk does not use OAuth. Configure a custom robot and supply webhookUrl in config.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('DingTalk webhook integration does not use OAuth authorization codes.');
+    },
+    verifyWebhook(signature, timestamp, _body) {
+        const secret = currentConfig?.webhookSecret ?? currentConfig?.appSecret;
+        if (!secret) {
+            logger.warn('[DingTalk] verifyWebhook: no secret configured, skipping verification');
+            return false;
+        }
+        const ts = parseInt(timestamp, 10);
+        if (isNaN(ts) || Math.abs(Date.now() - ts) > 3_600_000) {
+            logger.warn('[DingTalk] verifyWebhook: timestamp out of allowed range');
+            return false;
+        }
+        try {
+            const expected = createHmac('sha256', secret)
+                .update(`${timestamp}\n${secret}`, 'utf8')
+                .digest('base64');
+            return signature === expected;
+        }
+        catch (error) {
+            logger.error('[DingTalk] verifyWebhook failed:', error instanceof Error ? error : undefined);
+            return false;
+        }
+    },
+};
+// --- outbound adapter ---
+const outboundAdapter = {
+    async send(message) {
+        const cfg = currentConfig;
+        if (!cfg?.webhookUrl) {
+            return { success: false, error: 'webhookUrl is required for DingTalk outbound messages' };
+        }
+        const result = await postWebhook(cfg.webhookUrl, { msgtype: 'text', text: { content: message.text ?? '' } }, cfg.webhookSecret);
+        return result.ok
+            ? { success: true }
+            : { success: false, error: result.error ?? 'Failed to send message' };
+    },
+};
+// --- inbound adapter ---
+const MEDIA_TYPES = [DingTalkMsgType.IMAGE, DingTalkMsgType.AUDIO, DingTalkMsgType.VIDEO, DingTalkMsgType.FILE];
+const MEDIA_TYPE_MAP = {
+    image: 'image', video: 'video', audio: 'audio', file: 'file',
+};
+const inboundAdapter = {
+    parseMessage(payload) {
+        if (payload === null || typeof payload !== 'object')
+            return null;
+        const raw = payload;
+        if (!raw.msgtype || !raw.conversationId) {
+            logger.debug('[DingTalk] parseMessage: missing required fields, skipping');
+            return null;
+        }
+        if (![DingTalkMsgType.TEXT, ...MEDIA_TYPES].includes(raw.msgtype)) {
+            logger.debug(`[DingTalk] parseMessage: unsupported type '${raw.msgtype}', skipping`);
+            return null;
+        }
+        const attachments = [];
+        if (MEDIA_TYPES.includes(raw.msgtype)) {
+            const attachType = MEDIA_TYPE_MAP[raw.msgtype];
+            if (attachType)
+                attachments.push({ type: attachType });
+        }
+        return {
+            id: raw.msgId ?? `dt-${Date.now()}`,
+            provider: 'dingtalk',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: raw.senderId,
+            senderName: raw.senderNick,
+            senderUsername: raw.senderId,
+            chatType: raw.conversationType === '1' ? 'direct' : 'group',
+            chatId: raw.conversationId,
+            chatName: raw.conversationTitle,
+            threadId: undefined,
+            replyToId: undefined,
+            text: raw.text?.content ?? '',
+            rawContent: raw,
+            timestamp: new Date(),
+            attachments: attachments.length > 0 ? attachments : undefined,
+        };
+    },
+    parseCommand(_payload) { return null; },
+    parseAction(_payload) { return null; },
+    buildCommandResponse(response) {
+        return { msgtype: DingTalkMsgType.TEXT, text: { content: response.text ?? '' } };
+    },
+    buildActionResponse(response) {
+        return { msgtype: DingTalkMsgType.TEXT, text: { content: response.text ?? '' } };
+    },
+};
+// --- status adapter ---
+const statusAdapter = {
+    isConfigured(config) {
+        return !!config.webhookUrl;
+    },
+    async checkHealth(config) {
+        if (!config.webhookUrl) {
+            return { connected: false, error: 'webhookUrl is required' };
+        }
+        const start = Date.now();
+        try {
+            const response = await fetch('https://oapi.dingtalk.com/', { method: 'HEAD' });
+            return {
+                connected: response.status < 500,
+                latencyMs: Date.now() - start,
+                details: {
+                    webhookConfigured: true,
+                    signingEnabled: !!config.webhookSecret,
+                    appKeyConfigured: !!config.appKey,
+                    robotCodeConfigured: !!config.robotCode,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                latencyMs: Date.now() - start,
+                error: error instanceof Error ? error.message : 'Network error reaching DingTalk API',
+            };
+        }
+    },
+};
+// --- config helpers and provider export ---
+export function setDingTalkConfig(config) { currentConfig = config; }
+export function clearDingTalkConfig() { currentConfig = null; }
+export const dingtalkProvider = {
+    meta,
+    capabilities,
+    defaultConfig: { provider: 'dingtalk', enabled: true },
+    configSchema: DingTalkAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+export { DingTalkMsgType };
+//# sourceMappingURL=index.js.map