agent-sin 0.1.0

package/dist/builder/conversation-router.d.ts

@@ -0,0 +1,22 @@
+import { type ChatProgressEvent, type ChatTurn } from "../core/chat-engine.js";
+import type { AppConfig } from "../core/config.js";
+import type { AiImagePart, AiProgressHandler } from "../core/ai-provider.js";
+import { type IntentRuntime } from "./build-flow.js";
+export interface BuildProgressReporter {
+    onProgress: AiProgressHandler;
+    flush(): Promise<void>;
+}
+export interface RouteConversationMessageOptions {
+    config: AppConfig;
+    text: string;
+    history: ChatTurn[];
+    intentRuntime: IntentRuntime;
+    eventSource: "discord" | "telegram";
+    images?: AiImagePart[];
+    createBuildProgress(): BuildProgressReporter;
+    onBuildStart?(): Promise<void>;
+    onBuildDone?(): Promise<void>;
+    onChatProgress?(event: ChatProgressEvent): void;
+    onAiProgress?: AiProgressHandler;
+}
+export declare function routeConversationMessage(options: RouteConversationMessageOptions): Promise<string[]>;

package/dist/builder/conversation-router.js

@@ -0,0 +1,69 @@
+import { chatRespond, } from "../core/chat-engine.js";
+import { classifyPendingHandoff, enterBuildMode, handleBuildModeMessage, } from "./build-flow.js";
+import { l } from "../core/i18n.js";
+export async function routeConversationMessage(options) {
+    const { config, text, history, intentRuntime, eventSource, images = [], } = options;
+    if (intentRuntime.mode === "build") {
+        await options.onBuildStart?.();
+        const buildProgress = options.createBuildProgress();
+        const lines = await handleBuildModeMessage(config, text, intentRuntime, {
+            suggestExitOnOffTopic: true,
+            onProgress: buildProgress.onProgress,
+            history,
+        }, eventSource);
+        await buildProgress.flush();
+        await options.onBuildDone?.();
+        if (lines !== null) {
+            return lines;
+        }
+        // lines === null means handleBuildModeMessage auto-exited build mode;
+        // fall through so the normal chat engine (with skills) handles this turn.
+    }
+    if (intentRuntime.pending && !text.startsWith("/")) {
+        const approval = await classifyPendingHandoff(config, text, history, intentRuntime);
+        if (approval.decision === "approve") {
+            await options.onBuildStart?.();
+            const buildProgress = options.createBuildProgress();
+            const lines = await enterBuildMode(config, history, intentRuntime, { onProgress: buildProgress.onProgress }, approval.carry_over_text, eventSource);
+            await buildProgress.flush();
+            await options.onBuildDone?.();
+            return lines;
+        }
+        if (approval.decision === "reject") {
+            intentRuntime.pending = null;
+            await options.onBuildDone?.();
+            return [l("OK. Continuing in chat.", "わかりました。チャットを続けます。")];
+        }
+        // "discuss" → keep pending, fall through to chatRespond.
+    }
+    let modelFailed = false;
+    const lines = await chatRespond(config, text, history, {
+        eventSource,
+        preferredSkillId: intentRuntime.preferred_skill_id || undefined,
+        userImages: images,
+        onChatProgress: (event) => {
+            if (event.kind === "model_failed") {
+                modelFailed = true;
+            }
+            options.onChatProgress?.(event);
+        },
+        onAiProgress: options.onAiProgress,
+        onBuildSuggestion: (suggestion) => setPendingBuildSuggestion(intentRuntime, suggestion, text),
+    });
+    intentRuntime.preferred_skill_id = null;
+    if (modelFailed && lines.length === 0) {
+        return [l("The model call failed.", "モデル呼び出しでエラーになりました。")];
+    }
+    return lines;
+}
+function setPendingBuildSuggestion(intentRuntime, suggestion, userText) {
+    if (!intentRuntime.enabled || intentRuntime.mode !== "chat")
+        return;
+    intentRuntime.pending = {
+        type: suggestion.type,
+        skill_id: suggestion.skill_id,
+        original_text: userText,
+        reason: suggestion.reason || "chat build suggestion",
+    };
+    intentRuntime.pending_exit = null;
+}

package/dist/builder/intent-runtime-store.d.ts

@@ -0,0 +1,7 @@
+import type { IntentRuntime } from "./build-flow.js";
+type RuntimeRootKey = "channels" | "chats";
+export declare function loadIntentRuntimeMap(filePath: string, rootKey: RuntimeRootKey): Promise<Map<string, IntentRuntime>>;
+export declare function saveIntentRuntimeMap(filePath: string, rootKey: RuntimeRootKey, runtimes: Map<string, IntentRuntime>): Promise<void>;
+export declare function restoreIntentRuntime(runtime: IntentRuntime): IntentRuntime;
+export declare function isEmptyIntentRuntime(runtime: IntentRuntime): boolean;
+export {};

package/dist/builder/intent-runtime-store.js

@@ -0,0 +1,60 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function loadIntentRuntimeMap(filePath, rootKey) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        const data = JSON.parse(raw);
+        const entries = data[rootKey];
+        const map = new Map();
+        if (entries && typeof entries === "object") {
+            for (const [key, runtime] of Object.entries(entries)) {
+                if (!runtime || typeof runtime !== "object")
+                    continue;
+                map.set(key, restoreIntentRuntime(runtime));
+            }
+        }
+        return map;
+    }
+    catch {
+        return new Map();
+    }
+}
+export async function saveIntentRuntimeMap(filePath, rootKey, runtimes) {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const values = {};
+    for (const [key, runtime] of runtimes) {
+        if (!isEmptyIntentRuntime(runtime)) {
+            values[key] = runtime;
+        }
+    }
+    await writeFile(filePath, `${JSON.stringify({ [rootKey]: values, saved_at: new Date().toISOString() }, null, 2)}\n`, "utf8");
+}
+export function restoreIntentRuntime(runtime) {
+    const runtimeRecord = runtime;
+    const restoredBuild = runtime.build
+        ? {
+            ...runtime.build,
+            context_seed: [],
+            context_consumed: true,
+        }
+        : null;
+    return {
+        enabled: runtime.enabled !== false,
+        mode: runtime.mode === "build" ? "build" : "chat",
+        pending: runtime.pending ?? null,
+        pending_exit: runtimeRecord.pending_exit && typeof runtimeRecord.pending_exit === "object"
+            ? runtimeRecord.pending_exit
+            : null,
+        preferred_skill_id: typeof runtimeRecord.preferred_skill_id === "string" ? runtimeRecord.preferred_skill_id : null,
+        progress_detail: runtimeRecord.progress_detail === true,
+        build: restoredBuild,
+    };
+}
+export function isEmptyIntentRuntime(runtime) {
+    return (runtime.mode === "chat" &&
+        !runtime.pending &&
+        !runtime.build &&
+        !runtime.pending_exit &&
+        !runtime.preferred_skill_id &&
+        !runtime.progress_detail);
+}

package/dist/builder/progress-format.d.ts

@@ -0,0 +1,7 @@
+import type { AiProgressEvent } from "../core/ai-provider.js";
+export declare function progressIntervalMs(envName: string, fallback?: number): number;
+export declare function formatBuildProgress(event: AiProgressEvent, options?: {
+    detail?: boolean;
+}): string | null;
+export declare function formatDetailedBuildProgress(event: AiProgressEvent): string | null;
+export declare function cleanProgressText(text: string): string;

package/dist/builder/progress-format.js

@@ -0,0 +1,46 @@
+import { l } from "../core/i18n.js";
+export function progressIntervalMs(envName, fallback = 12000) {
+    const raw = Number.parseInt(process.env[envName] || "", 10);
+    if (Number.isFinite(raw) && raw >= 1000) {
+        return raw;
+    }
+    return fallback;
+}
+export function formatBuildProgress(event, options = {}) {
+    if (!options.detail) {
+        return null;
+    }
+    return formatDetailedBuildProgress(event);
+}
+export function formatDetailedBuildProgress(event) {
+    switch (event.kind) {
+        case "info":
+            return l(`Working: ${cleanProgressText(event.text)}`, `進めています: ${cleanProgressText(event.text)}`);
+        case "thinking": {
+            const detail = cleanProgressText(event.text || "");
+            return detail ? l(`Thinking: ${detail}`, `考えています: ${detail}`) : l("Thinking", "考えています");
+        }
+        case "tool": {
+            const name = cleanProgressText(event.name || "tool");
+            const detail = cleanProgressText(event.text || "");
+            return detail ? l(`Running tool: ${name} - ${detail}`, `ツール実行中: ${name} - ${detail}`) : l(`Running tool: ${name}`, `ツール実行中: ${name}`);
+        }
+        case "stderr": {
+            const detail = cleanProgressText(event.text);
+            return detail ? l(`Checking tool output: ${detail}`, `ツール出力を確認中: ${detail}`) : l("Checking tool output", "ツール出力を確認中");
+        }
+        case "message":
+            return l("Preparing response", "応答を整理しています");
+        default:
+            return null;
+    }
+}
+export function cleanProgressText(text) {
+    return text
+        .replace(/```/g, "")
+        .replace(/`/g, "'")
+        .replace(/@/g, "@\u200b")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 140);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};