agent-sin 0.1.0

package/dist/runtimes/typescript-runner.js

@@ -0,0 +1,172 @@
+import { copyFile, mkdir, readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+import { resolveSkillEntryPath } from "../core/skill-registry.js";
+import { getAiProvider } from "../core/ai-provider.js";
+import { notify as runNotify } from "../core/notifier.js";
+export async function runTypeScriptSkill(config, manifest, input) {
+    const entry = await resolveSkillEntryPath(manifest);
+    const skillDir = await realpath(manifest.dir);
+    const moduleUrl = await prepareModule(skillDir, entry);
+    const module = await import(`${moduleUrl.href}?run=${crypto.randomUUID()}`);
+    const handler = resolveHandler(module, manifest.handler);
+    const context = createContext(config, manifest, input.memory);
+    const result = await handler(context.ctx, input);
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+        throw new Error(`TypeScript skill did not return a result object: ${manifest.id}`);
+    }
+    return {
+        result: result,
+        memory_updates: context.memoryUpdates,
+        logs: context.logs,
+    };
+}
+async function prepareModule(skillDir, entry) {
+    if (entry.endsWith(".ts") || entry.endsWith(".tsx")) {
+        const cacheDir = path.join(os.tmpdir(), "agent-sin-ts-runtime", crypto.randomUUID());
+        await mkdir(cacheDir, { recursive: true });
+        await writeFile(path.join(cacheDir, "package.json"), JSON.stringify({ type: "module" }), "utf8");
+        await prepareDirectory(skillDir, cacheDir);
+        const relativeEntry = path.relative(skillDir, entry).replace(/\.(tsx?|mts|cts)$/, ".js");
+        return pathToFileURL(path.join(cacheDir, relativeEntry));
+    }
+    return pathToFileURL(entry);
+}
+async function prepareDirectory(sourceDir, targetDir) {
+    for (const entry of await readdir(sourceDir, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+            continue;
+        }
+        const sourcePath = path.join(sourceDir, entry.name);
+        const targetPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(targetPath, { recursive: true });
+            await prepareDirectory(sourcePath, targetPath);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        if (/\.(tsx?|mts|cts)$/.test(entry.name)) {
+            const outFile = targetPath.replace(/\.(tsx?|mts|cts)$/, ".js");
+            await transpileFile(sourcePath, outFile);
+            continue;
+        }
+        if (/\.(mjs|cjs|js|json)$/.test(entry.name)) {
+            await mkdir(path.dirname(targetPath), { recursive: true });
+            await copyFile(sourcePath, targetPath);
+        }
+    }
+}
+async function transpileFile(sourcePath, targetPath) {
+    const source = await readFile(sourcePath, "utf8");
+    const compiled = ts.transpileModule(source, {
+        fileName: sourcePath,
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ES2022,
+            esModuleInterop: true,
+            sourceMap: false,
+        },
+    });
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, compiled.outputText, "utf8");
+}
+function resolveHandler(module, handlerName) {
+    const direct = module[handlerName];
+    if (typeof direct === "function") {
+        return direct;
+    }
+    const fallback = module.default;
+    if (fallback && typeof fallback === "object" && typeof fallback[handlerName] === "function") {
+        return fallback[handlerName];
+    }
+    if (handlerName === "default" && typeof fallback === "function") {
+        return fallback;
+    }
+    throw new Error(`TypeScript skill handler not found: ${handlerName}`);
+}
+function createContext(config, manifest, initialMemory) {
+    const memory = new Map(Object.entries(initialMemory || {}));
+    const memoryUpdates = {};
+    const logs = [];
+    const allowedSteps = new Map((manifest.ai_steps || []).map((step) => [step.id, step]));
+    return {
+        ctx: {
+            log: {
+                info: (message) => logs.push({ level: "info", message: String(message) }),
+                warn: (message) => logs.push({ level: "warn", message: String(message) }),
+                error: (message) => logs.push({ level: "error", message: String(message) }),
+            },
+            ai: {
+                run: async (stepId, payload) => {
+                    const step = allowedSteps.get(stepId);
+                    if (!step) {
+                        throw new Error(`AI step is not defined for this skill: ${stepId}`);
+                    }
+                    const modelId = step.model || config.chat_model_id;
+                    try {
+                        const messages = [
+                            { role: "system", content: `You are an AI step "${step.id}" of an Agent-Sin skill. Purpose: ${step.purpose}` },
+                            { role: "user", content: typeof payload === "string" ? payload : JSON.stringify(payload) },
+                        ];
+                        const response = await getAiProvider()(config, { model_id: modelId, messages });
+                        return {
+                            status: "ok",
+                            step_id: stepId,
+                            model_id: modelId,
+                            provider: response.provider,
+                            text: response.text,
+                        };
+                    }
+                    catch (error) {
+                        if (step.optional) {
+                            return {
+                                status: "skipped",
+                                step_id: stepId,
+                                reason: error instanceof Error ? error.message : String(error),
+                                payload,
+                            };
+                        }
+                        throw error;
+                    }
+                },
+            },
+            notify: async (args) => {
+                const result = await runNotify({
+                    title: args.title,
+                    body: args.body,
+                    subtitle: args.subtitle,
+                    sound: args.sound,
+                    channel: args.channel,
+                    to: args.to,
+                    discordThreadId: args.discordThreadId,
+                    telegramThreadId: args.telegramThreadId,
+                });
+                return { ok: result.ok, channel: result.channel, detail: result.detail };
+            },
+            memory: {
+                get: async (key) => {
+                    if (manifest.memory?.read !== true) {
+                        return undefined;
+                    }
+                    return memory.get(key);
+                },
+                set: async (key, value) => {
+                    if (manifest.memory?.write !== true) {
+                        throw new Error("Memory write is not allowed for this skill");
+                    }
+                    memory.set(key, value);
+                    memoryUpdates[key] = value;
+                    return true;
+                },
+            },
+            now: () => new Date().toISOString(),
+        },
+        memoryUpdates,
+        logs,
+    };
+}

package/dist/skills-sdk/types.d.ts

@@ -0,0 +1,38 @@
+export interface SkillInput {
+    args: Record<string, unknown>;
+    trigger: {
+        type: string;
+        id: string;
+        time: string;
+    };
+    sources: Record<string, unknown>;
+    memory: Record<string, unknown>;
+}
+export type NotifyChannel = "auto" | "macos" | "discord" | "telegram" | "slack" | "mail" | "stderr";
+export interface NotifyArgs {
+    title: string;
+    body: string;
+    subtitle?: string;
+    sound?: boolean;
+    channel?: NotifyChannel;
+    to?: string;
+    discordThreadId?: string;
+    telegramThreadId?: string;
+}
+export interface NotifyOutcome {
+    ok: boolean;
+    channel: string;
+    detail?: string;
+}
+export interface SkillResult {
+    status: "ok" | "skipped" | "error";
+    title: string;
+    summary: string;
+    outputs: Record<string, {
+        content?: string;
+        frontmatter?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    data: Record<string, unknown>;
+    suggestions: string[];
+}

package/dist/skills-sdk/types.js

@@ -0,0 +1 @@
+export {};

package/dist/telegram/bot.d.ts

@@ -0,0 +1,94 @@
+import { type AppConfig } from "../core/config.js";
+import { type ChatTurn } from "../core/chat-engine.js";
+import type { AiProgressEvent } from "../core/ai-provider.js";
+import { type IntentRuntime } from "../builder/build-flow.js";
+export interface TelegramUser {
+    id: number;
+    is_bot?: boolean;
+    first_name?: string;
+    username?: string;
+}
+export interface TelegramChat {
+    id: number;
+    type: "private" | "group" | "supergroup" | "channel";
+    title?: string;
+    username?: string;
+}
+export interface TelegramMessageEntity {
+    type: string;
+    offset: number;
+    length: number;
+    user?: TelegramUser;
+}
+export interface TelegramPhotoSize {
+    file_id: string;
+    file_unique_id?: string;
+    width: number;
+    height: number;
+    file_size?: number;
+}
+export interface TelegramDocument {
+    file_id: string;
+    file_unique_id?: string;
+    file_name?: string;
+    mime_type?: string;
+    file_size?: number;
+}
+export interface TelegramMessage {
+    message_id: number;
+    message_thread_id?: number;
+    is_topic_message?: boolean;
+    from?: TelegramUser;
+    chat: TelegramChat;
+    date?: number;
+    text?: string;
+    caption?: string;
+    entities?: TelegramMessageEntity[];
+    caption_entities?: TelegramMessageEntity[];
+    reply_to_message?: TelegramMessage;
+    photo?: TelegramPhotoSize[];
+    document?: TelegramDocument;
+}
+export interface TelegramUpdate {
+    update_id: number;
+    message?: TelegramMessage;
+}
+export interface TelegramSendOptions {
+    threadId?: number;
+    replyToMessageId?: number;
+}
+export interface TelegramMessageContext {
+    isPrivate: boolean;
+    isMentioned: boolean;
+    isReplyToBot: boolean;
+    isAllowed: boolean;
+    isListenChat: boolean;
+}
+export interface TelegramIdentityCandidate {
+    updateId: number;
+    userId: string;
+    chatId: string;
+    chatType: TelegramChat["type"];
+    displayName: string;
+    username?: string;
+}
+export declare function runTelegramBot(config: AppConfig): Promise<number>;
+export declare function parseTelegramIdList(raw: string): Set<string>;
+export declare function classifyTelegramMessage(message: TelegramMessage, botUserId: string | null, botUsername: string | null, allowedUserIds: Set<string>, listenChatIds?: Set<string>): TelegramMessageContext;
+export declare function shouldRespond(ctx: TelegramMessageContext): boolean;
+export declare function extractTelegramIdentityCandidates(updates: TelegramUpdate[]): TelegramIdentityCandidate[];
+export declare function telegramChatKey(message: TelegramMessage): string;
+export declare function stripTelegramBotMention(content: string, botUsername: string | null): string;
+export declare function formatTelegramUserMessageForHistory(message: TelegramMessage, botUsername: string | null, botUserId?: string | null): string;
+export declare function formatTelegramReplyContext(message: TelegramMessage, botUsername: string | null, botUserId: string | null): string;
+export declare function buildChatHistoryFromTelegramMessages(messages: TelegramMessage[], botUserId: string | null, botUsername: string | null, allowedUserIds: Set<string>): ChatTurn[];
+export declare function chunkTelegramMessage(text: string, max?: number): string[];
+export declare function formatTelegramBuildProgress(event: AiProgressEvent, options?: {
+    detail?: boolean;
+}): string | null;
+export declare function shouldUseTelegramDraftStream(message: TelegramMessage): boolean;
+export declare function telegramSendPayload(chatId: string, content: string, options?: TelegramSendOptions): Record<string, unknown>;
+export declare function telegramDraftPayload(message: TelegramMessage, draftId: number, text: string): Record<string, unknown>;
+export declare function formatTelegramDraftProgress(event: AiProgressEvent): string | null;
+export declare function loadTelegramHistories(filePath: string): Promise<Map<string, ChatTurn[]>>;
+export declare function loadTelegramIntentRuntimes(filePath: string): Promise<Map<string, IntentRuntime>>;