agent-sin 0.1.0

package/dist/builder/build-action-classifier.js

@@ -0,0 +1,142 @@
+import { getAiProvider } from "../core/ai-provider.js";
+const RECENT_HISTORY_TURNS = 8;
+export async function classifyHandoffApproval(config, userText, history, pending, options = {}) {
+    const trimmed = userText.trim();
+    if (!trimmed) {
+        return { decision: "discuss", reason: "empty input" };
+    }
+    const system = handoffApprovalPrompt(pending);
+    const messages = buildMessages(system, history, trimmed);
+    const parsed = await callJsonClassifier(config, messages, options.modelId);
+    if (!parsed) {
+        return { decision: "discuss", reason: "classifier fallback" };
+    }
+    const raw = String(parsed.decision || "").trim().toLowerCase();
+    const decision = raw === "approve" ? "approve" : raw === "reject" ? "reject" : "discuss";
+    const carryOver = typeof parsed.carry_over_text === "string" ? parsed.carry_over_text.trim() : "";
+    return {
+        decision,
+        carry_over_text: carryOver || undefined,
+        reason: typeof parsed.reason === "string" ? parsed.reason.slice(0, 240) : undefined,
+    };
+}
+export async function classifyBuildModeAction(config, userText, history, build, options = {}) {
+    const trimmed = userText.trim();
+    if (!trimmed) {
+        return { action: "continue", reason: "empty input" };
+    }
+    const system = buildModeActionPrompt(build);
+    const messages = buildMessages(system, history, trimmed);
+    const parsed = await callJsonClassifier(config, messages, options.modelId);
+    if (!parsed) {
+        return { action: "continue", reason: "classifier fallback" };
+    }
+    const raw = String(parsed.action || "").trim().toLowerCase();
+    const action = raw === "exit" ? "exit"
+        : raw === "register" ? "register"
+            : raw === "test" ? "test"
+                : "continue";
+    return {
+        action,
+        reason: typeof parsed.reason === "string" ? parsed.reason.slice(0, 240) : undefined,
+    };
+}
+function buildMessages(system, history, userText) {
+    const recent = history.slice(-RECENT_HISTORY_TURNS).map((turn) => ({
+        role: (turn.role === "tool" ? "tool" : turn.role),
+        content: turn.content,
+    }));
+    return [
+        { role: "system", content: system },
+        ...recent,
+        {
+            role: "user",
+            content: `Classify the following user reply.\n\n<reply>${userText}</reply>\n\nReturn JSON only.`,
+        },
+    ];
+}
+async function callJsonClassifier(config, messages, modelId) {
+    let response;
+    try {
+        response = await getAiProvider()(config, {
+            model_id: modelId || config.chat_model_id,
+            messages,
+            temperature: 0,
+        });
+    }
+    catch {
+        return null;
+    }
+    return parseClassifierJson(response.text);
+}
+function parseClassifierJson(text) {
+    const stripped = text
+        .replace(/```json\s*/gi, "")
+        .replace(/```\s*$/g, "")
+        .trim();
+    const start = stripped.indexOf("{");
+    const end = stripped.lastIndexOf("}");
+    if (start < 0 || end <= start) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(stripped.slice(start, end + 1));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function handoffApprovalPrompt(pending) {
+    const typeLabel = pending.type === "edit" ? "edit existing skill" : "create new skill";
+    return [
+        "You decide how the user is responding to a pending build-mode proposal.",
+        "There is a pending proposal:",
+        `- type: ${typeLabel}`,
+        `- skill_id: ${pending.skill_id}`,
+        `- reason: ${pending.reason}`,
+        `- original_user_request: ${truncate(pending.original_text, 400)}`,
+        "",
+        "Decide one of three labels:",
+        '- "approve": the user wants to go ahead with the proposal (any natural phrasing in any language: "yes", "do it", "make it", "go", "please", "create it", "let\'s do it", はい, つくって, 作って, やって, お願い, 進めて, etc., including approvals that bundle additional requirements or constraints).',
+        '- "reject": the user wants to cancel or abandon the proposal ("no", "cancel", "stop", やめて, キャンセル, やっぱり違う, etc.).',
+        '- "discuss": the user is asking a clarifying question, providing more requirements without explicit approval, or continuing the conversation without committing. When in doubt, choose discuss.',
+        "",
+        "If approve and the reply contains extra requirements or constraints beyond the bare approval, copy that extra part into carry_over_text verbatim (in the user's language). Omit pure approval words (yes / つくって / etc.). If there is nothing extra, omit carry_over_text.",
+        "",
+        "Return exactly one JSON object. No markdown fences:",
+        '{"decision":"approve|reject|discuss","carry_over_text":"...","reason":"short why"}',
+    ].join("\n");
+}
+function buildModeActionPrompt(build) {
+    const typeLabel = build.type === "edit" ? "editing an existing skill" : "creating a new skill";
+    return [
+        "You decide how the user wants to proceed inside build mode.",
+        "Current build session:",
+        `- mode: ${typeLabel}`,
+        `- skill_id: ${build.skill_id}`,
+        `- original_request: ${truncate(build.original_text, 400)}`,
+        "",
+        "Choose one of four actions:",
+        '- "exit": the user wants to leave build mode and return to plain chat ("stop", "go back", "/back", やめる, 戻る, もういい, 中止, キャンセル, or any natural cancel/exit phrase in any language).',
+        '- "register": the user wants to register/install the current draft as a usable skill ("register it", "install", 登録して, 本登録, これでOK, これで保存, 公開して).',
+        '- "test": the user wants to test/run the current draft ("test it", "run it", 動かして, 試して, テスト).',
+        '- "continue": anything else — additional requirements, edits, design discussion, environment variables, default request to keep building.',
+        "",
+        "If the user is asking to fix or change implementation details, prefer 'continue' over 'register' or 'test'.",
+        "If unsure, choose 'continue'.",
+        "",
+        "Return exactly one JSON object. No markdown fences:",
+        '{"action":"exit|register|test|continue","reason":"short why"}',
+    ].join("\n");
+}
+function truncate(text, max) {
+    if (!text)
+        return "";
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max)}...`;
+}

package/dist/builder/build-commands.d.ts

@@ -0,0 +1,19 @@
+import type { AppConfig } from "../core/config.js";
+import type { AiProgressHandler } from "../core/ai-provider.js";
+import { type BuilderAccessMode } from "./builder-session.js";
+export declare function buildLines(config: AppConfig, skillId: string | undefined, options?: {
+    prompt?: string;
+    runtime?: "python" | "typescript";
+    builder?: string;
+    accessMode?: BuilderAccessMode;
+    onProgress?: AiProgressHandler;
+}): Promise<string[]>;
+export declare function buildChatLines(config: AppConfig, skillId: string, message: string, options?: {
+    onProgress?: AiProgressHandler;
+}): Promise<string[]>;
+export declare function buildTestLines(config: AppConfig, skillId: string, payload?: Record<string, unknown>): Promise<string[]>;
+export declare function buildStatusLines(config: AppConfig, skillId: string): Promise<string[]>;
+export declare function buildRegisterLines(config: AppConfig, skillId: string, options?: {
+    overwrite?: boolean;
+}): Promise<string[]>;
+export declare function buildListLines(config: AppConfig): Promise<string[]>;

package/dist/builder/build-commands.js

@@ -0,0 +1,133 @@
+import { l } from "../core/i18n.js";
+import { buildDraftWithAgent, createBuildSession, inspectBuildReadiness, listBuildDrafts, readBuildStatus, registerBuildSkill, testBuildDraft, } from "./builder-session.js";
+export async function buildLines(config, skillId, options = {}) {
+    const session = await createBuildSession(config, skillId, {
+        runtime: options.runtime,
+        accessMode: options.accessMode,
+    });
+    const lines = [
+        l(`Build workspace ready: ${session.workspace}`, `ビルド用ワークスペース準備完了: ${session.workspace}`),
+        `Draft: ${session.draft_dir}`,
+        `Review: ${session.review_path}`,
+        l('Next: agent-sin build chat <skill-id> "what to build"', '次: agent-sin build chat <skill-id> "作りたい内容"'),
+        l("Test: agent-sin build test <skill-id>", "テスト: agent-sin build test <skill-id>"),
+        l("Use: the skill is saved under skills/<skill-id> as soon as files are written", "利用: ファイルが書かれた時点で skills/<skill-id> 配下に保存されています"),
+    ];
+    if (!options.prompt?.trim()) {
+        return lines;
+    }
+    const result = await buildDraftWithAgent(config, session.skill_id, options.prompt, {
+        runtime: options.runtime,
+        builder: options.builder,
+        accessMode: options.accessMode,
+        onProgress: options.onProgress,
+    });
+    return [
+        l(`Build draft updated: ${result.session.skill_id}`, `ビルドドラフトを更新しました: ${result.session.skill_id}`),
+        `Builder: ${result.model_id} (${result.provider})`,
+        l(`Summary: ${result.summary}`, `要約: ${result.summary}`),
+        ...result.files_written.map((file) => `  + ${file}`),
+        l(`Next: agent-sin build test ${result.session.skill_id}`, `次: agent-sin build test ${result.session.skill_id}`),
+    ];
+}
+export async function buildChatLines(config, skillId, message, options = {}) {
+    const result = await buildDraftWithAgent(config, skillId, message, {
+        onProgress: options.onProgress,
+    });
+    return [
+        l(`Build draft updated: ${result.session.skill_id}`, `ビルドドラフトを更新しました: ${result.session.skill_id}`),
+        `Builder: ${result.model_id} (${result.provider})`,
+        l(`Summary: ${result.summary}`, `要約: ${result.summary}`),
+        ...result.files_written.map((file) => `  + ${file}`),
+        l(`Next: agent-sin build test ${result.session.skill_id}`, `次: agent-sin build test ${result.session.skill_id}`),
+    ];
+}
+export async function buildTestLines(config, skillId, payload) {
+    const result = await testBuildDraft(config, skillId, payload);
+    if (result.missing_env && result.missing_env.length > 0) {
+        const lines = [l("Waiting for settings. These required values are missing:", "設定待ちです。必要な値がまだ入っていません:")];
+        for (const entry of result.missing_env) {
+            lines.push(`  - ${entry.name}${entry.description ? ` - ${entry.description}` : ""}`);
+        }
+        lines.push(l("After saving them, ask to test again.", "保存できたら、もう一度「テストして」と伝えてください。"));
+        return lines;
+    }
+    if (result.safe_to_register) {
+        return [l(`✅ Ready to run. ${result.summary || ""}`, `✅ 動かせる状態です。${result.summary || ""}`).trim(), l("Ready to use.", "登録できます。")];
+    }
+    // failed
+    const lines = [l(`❌ Still needs fixes. ${result.summary || ""}`, `❌ まだ直す必要があります。${result.summary || ""}`).trim()];
+    for (const error of result.validation.errors) {
+        lines.push(`[error] ${error}`);
+    }
+    if (result.details) {
+        const tail = result.details.split("\n").slice(0, 20);
+        lines.push("```", ...tail, "```");
+    }
+    return lines;
+}
+export async function buildStatusLines(config, skillId) {
+    const status = await readBuildStatus(config, skillId);
+    const userState = buildUserState(config, status.result, status.state.status);
+    const lines = [
+        `${status.state.skill_id}: ${userState}`,
+    ];
+    if (status.result) {
+        if (typeof status.result.summary === "string") {
+            lines.push(status.result.summary);
+        }
+        const missing = Array.isArray(status.result.missing_env) ? status.result.missing_env : [];
+        for (const entry of missing) {
+            if (entry && typeof entry === "object" && typeof entry.name === "string") {
+                lines.push(l(`Required setting: ${entry.name}`, `必要な設定: ${entry.name}`));
+            }
+        }
+    }
+    return lines;
+}
+export async function buildRegisterLines(config, skillId, options = {}) {
+    const readiness = await inspectBuildReadiness(config, skillId);
+    if (readiness.status === "needs_config") {
+        const lines = [l("Waiting for settings. Save these required values before using it:", "設定待ちです。登録前に必要な値を保存してください:")];
+        for (const entry of readiness.missing_env || []) {
+            lines.push(`  - ${entry.name}${entry.description ? ` - ${entry.description}` : ""}`);
+        }
+        return lines;
+    }
+    if (!readiness.safe_to_register) {
+        return [
+            readiness.status === "incomplete" ? l("Not complete yet. Describe what you want a little more.", "未完成です。もう少し要望を伝えてください。") : l("Still needs fixes.", "まだ直す必要があります。"),
+            readiness.summary,
+        ].filter(Boolean);
+    }
+    const registered = await registerBuildSkill(config, skillId, options);
+    return [l(`✅ "${registered.skill_id}" is ready and can be called from chat.`, `✅ "${registered.skill_id}" は登録済みです。チャットから呼び出せます。`)];
+}
+export async function buildListLines(config) {
+    const drafts = await listBuildDrafts(config);
+    if (drafts.length === 0) {
+        return [
+            l("No skill drafts.", "作成中のスキルはありません。"),
+            l("Create one: agent-sin build [skill-id] --prompt \"...\"", "新規作成: agent-sin build [skill-id] --prompt \"…\""),
+        ];
+    }
+    const lines = [
+        l(`Skill drafts (${drafts.length}):`, `作成中のスキル (${drafts.length}):`),
+        l("id\tstatus\tupdated", "id\t状態\tupdated"),
+    ];
+    for (const draft of drafts) {
+        const updated = draft.updated_at ? draft.updated_at.replace("T", " ").replace(/\..*$/, "") : "-";
+        lines.push(`${draft.skill_id}\t${buildUserState(config, { safe_to_register: draft.safe_to_register }, draft.status)}\t${updated}`);
+    }
+    lines.push("");
+    lines.push(l("To continue, send a request with that skill name.", "続きは、そのスキル名を指定して要望を送ってください。"));
+    return lines;
+}
+function buildUserState(_config, result, status) {
+    if (status === "needs_config" || result?.status === "needs_config")
+        return l("needs config", "設定待ち");
+    if (result?.safe_to_register === true || status === "ready") {
+        return l("ready", "登録済み");
+    }
+    return l("drafting", "未完成");
+}

package/dist/builder/build-flow.d.ts

@@ -0,0 +1,72 @@
+import type { AppConfig } from "../core/config.js";
+import type { ChatTurn } from "../core/chat-engine.js";
+import type { AiProgressHandler } from "../core/ai-provider.js";
+import { type BuilderHandoffTurn } from "./builder-session.js";
+export interface PendingHandoff {
+    type: "create" | "edit";
+    skill_id: string;
+    original_text: string;
+    reason: string;
+}
+export interface PendingBuildExit {
+    reason: string;
+}
+export type BuilderEventSource = "discord" | "telegram" | "cli";
+export interface BuildModeState {
+    type: "create" | "edit";
+    skill_id: string;
+    skill_name?: string | null;
+    context_seed: BuilderHandoffTurn[];
+    context_consumed: boolean;
+    original_text: string;
+    event_source?: BuilderEventSource;
+}
+export interface IntentRuntime {
+    pending: PendingHandoff | null;
+    pending_exit: PendingBuildExit | null;
+    preferred_skill_id: string | null;
+    progress_detail: boolean;
+    enabled: boolean;
+    mode: "chat" | "build";
+    build: BuildModeState | null;
+}
+export declare function createIntentRuntime(enabled?: boolean): IntentRuntime;
+export declare function parseEnvDirective(text: string): {
+    name: string;
+    value: string;
+} | null;
+export declare function isReservedAgentSinEnv(name: string): boolean;
+export declare function looksLikeRawSecretValue(text: string): boolean;
+export declare function extractAutoSaveSecretValue(text: string, envName?: string): string | null;
+export declare function tryAutoSaveBuildEnv(config: AppConfig, build: BuildModeState, text: string): Promise<string[] | null>;
+export interface BuildHandoffApproval {
+    decision: "approve" | "reject" | "discuss";
+    carry_over_text?: string;
+}
+export declare function classifyPendingHandoff(config: AppConfig, text: string, history: ChatTurn[], intentRuntime: IntentRuntime): Promise<BuildHandoffApproval>;
+export declare function renderBuildFooter(intentRuntime: IntentRuntime, options: {
+    exitPrefix: "!" | "/";
+    languageHint?: string | string[];
+}): string;
+/**
+ * Decide whether to append the build-mode footer to a reply.
+ */
+export declare function shouldShowBuildFooter(opts: {
+    intentRuntime: IntentRuntime;
+    userText: string;
+    replyLines: string[];
+    isBuildEntry?: boolean;
+}): boolean;
+export interface BuildModeHandlerOptions {
+    onProgress?: AiProgressHandler;
+    /** Kept for compatibility; build mode now exits only through explicit local commands. */
+    suggestExitOnOffTopic?: boolean;
+    /** Recent chat history used to detect off-topic skill-run / chat messages. */
+    history?: ChatTurn[];
+}
+export interface BuildAutoExitDecision {
+    preferred_skill_id: string | null;
+    reason: string;
+}
+export declare function enterBuildMode(config: AppConfig, history: ChatTurn[], intentRuntime: IntentRuntime, hooks?: BuildModeHandlerOptions, extraText?: string, eventSource?: BuilderEventSource): Promise<string[]>;
+export declare function handleBuildModeMessage(config: AppConfig, text: string, intentRuntime: IntentRuntime, hooks?: BuildModeHandlerOptions, eventSource?: BuilderEventSource): Promise<string[] | null>;