agent-sin 0.1.0

package/dist/core/update-notifier.js

@@ -0,0 +1,140 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import https from "node:https";
+import { defaultWorkspace } from "./config.js";
+import { l } from "./i18n.js";
+const PACKAGE_NAME = "agent-sin";
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 5000;
+function packageJsonPath() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, "..", "..", "package.json");
+}
+let cachedCurrentVersion = null;
+async function readCurrentVersion() {
+    if (cachedCurrentVersion)
+        return cachedCurrentVersion;
+    try {
+        const raw = await readFile(packageJsonPath(), "utf8");
+        const pkg = JSON.parse(raw);
+        cachedCurrentVersion = pkg.version || "0.0.0";
+    }
+    catch {
+        cachedCurrentVersion = "0.0.0";
+    }
+    return cachedCurrentVersion;
+}
+function cachePath(workspace) {
+    return path.join(workspace, "update-check.json");
+}
+async function loadCache(workspace) {
+    try {
+        const raw = await readFile(cachePath(workspace), "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            lastCheckedAt: parsed.lastCheckedAt ?? null,
+            latestVersion: parsed.latestVersion ?? null,
+            bannerShownDate: parsed.bannerShownDate ?? null,
+        };
+    }
+    catch {
+        return { lastCheckedAt: null, latestVersion: null, bannerShownDate: null };
+    }
+}
+async function saveCache(workspace, cache) {
+    try {
+        await mkdir(workspace, { recursive: true });
+        await writeFile(cachePath(workspace), JSON.stringify(cache, null, 2), "utf8");
+    }
+    catch {
+        // ignore - non-critical
+    }
+}
+function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { timeout: FETCH_TIMEOUT_MS, headers: { accept: "application/json" } }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                body += chunk;
+            });
+            res.on("end", () => {
+                try {
+                    const parsed = JSON.parse(body);
+                    resolve(parsed.version ?? null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.on("error", () => resolve(null));
+    });
+}
+function compareSemver(a, b) {
+    const pa = a.split(/[.+-]/)[0].split(".").map((s) => parseInt(s, 10) || 0);
+    const pb = b.split(/[.+-]/)[0].split(".").map((s) => parseInt(s, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i += 1) {
+        const av = pa[i] ?? 0;
+        const bv = pb[i] ?? 0;
+        if (av !== bv)
+            return av - bv;
+    }
+    return 0;
+}
+function todayKey() {
+    const d = new Date();
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+function isDisabled() {
+    const flag = (process.env.AGENT_SIN_DISABLE_UPDATE_CHECK || "").trim().toLowerCase();
+    return flag === "1" || flag === "true" || flag === "yes";
+}
+export function scheduleUpdateCheck(workspace = defaultWorkspace()) {
+    if (isDisabled())
+        return;
+    void (async () => {
+        const cache = await loadCache(workspace);
+        const now = Date.now();
+        const lastChecked = cache.lastCheckedAt ? Date.parse(cache.lastCheckedAt) : 0;
+        if (Number.isFinite(lastChecked) && now - lastChecked < CHECK_INTERVAL_MS)
+            return;
+        const latest = await fetchLatestVersion();
+        if (!latest)
+            return;
+        await saveCache(workspace, {
+            ...cache,
+            lastCheckedAt: new Date().toISOString(),
+            latestVersion: latest,
+        });
+    })();
+}
+export async function consumeUpdateBanner(workspace = defaultWorkspace()) {
+    if (isDisabled())
+        return null;
+    const cache = await loadCache(workspace);
+    if (!cache.latestVersion)
+        return null;
+    const current = await readCurrentVersion();
+    if (compareSemver(cache.latestVersion, current) <= 0)
+        return null;
+    const today = todayKey();
+    if (cache.bannerShownDate === today)
+        return null;
+    await saveCache(workspace, { ...cache, bannerShownDate: today });
+    return l(`A new version v${cache.latestVersion} is available (current v${current}). Update: npm i -g ${PACKAGE_NAME}@latest`, `新しいバージョン v${cache.latestVersion} があります（現在 v${current}）。更新: npm i -g ${PACKAGE_NAME}@latest`);
+}

package/dist/discord/bot.d.ts

@@ -0,0 +1,96 @@
+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";
+import { type SkillManifest } from "../core/skill-registry.js";
+declare const STATUS_EMOJI: {
+    readonly received: "👀";
+    readonly thinking: "🤔";
+    readonly tool: "🛠️";
+    readonly done: "✅";
+    readonly error: "⚠️";
+};
+export type StatusKind = keyof typeof STATUS_EMOJI;
+export interface DiscordUser {
+    id: string;
+    username: string;
+    bot?: boolean;
+}
+export interface DiscordMessage {
+    id: string;
+    channel_id: string;
+    guild_id?: string;
+    author: DiscordUser;
+    content: string;
+    mentions: DiscordUser[];
+    attachments?: DiscordAttachment[];
+}
+export interface DiscordAttachment {
+    id?: string;
+    filename?: string;
+    title?: string;
+    description?: string;
+    content_type?: string;
+    size?: number;
+    url?: string;
+    proxy_url?: string;
+}
+export interface MessageContext {
+    isDirect: boolean;
+    isMentioned: boolean;
+    isAllowed: boolean;
+    isListenChannel: boolean;
+    isBotThread: boolean;
+}
+export declare function shouldRespond(ctx: MessageContext): boolean;
+export declare function renderModeBadge(_intentRuntime: IntentRuntime): string;
+export declare function withModeBadge(intentRuntime: IntentRuntime, lines: string[], options?: {
+    userText?: string;
+    isBuildEntry?: boolean;
+}): string[];
+export declare function runDiscordBot(config: AppConfig): Promise<number>;
+export declare function parseSnowflakeList(raw: string): Set<string>;
+/** @deprecated use parseSnowflakeList */
+export declare const parseAllowedUserIds: typeof parseSnowflakeList;
+export declare function classifyMessage(message: DiscordMessage, botUserId: string | null, allowedUserIds: Set<string>, listenChannelIds?: Set<string>, botThreadIds?: Set<string>): MessageContext;
+export declare function stripBotMention(content: string, botUserId: string): string;
+export declare function stripBadgePrefix(content: string): string;
+export declare function buildChatHistoryFromMessages(messages: DiscordMessage[], botUserId: string | null, allowedUserIds: Set<string>): ChatTurn[];
+export declare function formatDiscordUserMessageForHistory(message: DiscordMessage, botUserId: string | null): string;
+export declare function formatDiscordAttachmentSummary(attachments: DiscordAttachment[] | undefined): string;
+export declare function shouldResetDiscordHistory(ctx: MessageContext): boolean;
+export declare function chunkMessage(text: string, max?: number): string[];
+export declare function formatDiscordBuildProgress(event: AiProgressEvent, options?: {
+    detail?: boolean;
+}): string | null;
+export type TodoSlashParse = {
+    kind: "help";
+    lines: string[];
+} | {
+    kind: "error";
+    lines: string[];
+} | {
+    kind: "run";
+    skillId: "todo-add" | "todo-list" | "todo-done" | "todo-delete";
+    args: Record<string, unknown>;
+};
+export declare function parseTodoSlashCommand(text: string): TodoSlashParse | null;
+export type ModelSlashParse = {
+    kind: "help";
+    lines: string[];
+} | {
+    kind: "list";
+} | {
+    kind: "set";
+    id: string;
+};
+export declare function parseModelSlashCommand(text: string): ModelSlashParse | null;
+export declare function manifestToSlashDefinition(manifest: SkillManifest): ({
+    name: string;
+} & Record<string, unknown>) | null;
+export declare function composeSlashCommandDefinitions(config: AppConfig): Promise<ReadonlyArray<{
+    name: string;
+} & Record<string, unknown>>>;
+export declare function makeThreadName(text: string): string;
+export declare function loadIntentRuntimes(filePath: string): Promise<Map<string, IntentRuntime>>;
+export {};