agent-sin 0.1.12 → 0.1.15

package/dist/core/memo-migration.js

@@ -0,0 +1,422 @@
+import { mkdir, readdir, readFile, rename, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getAiProvider } from "./ai-provider.js";
+const MIGRATION_MARKER = ".memo-flat-structure-v1.migrated";
+const DATE_FILE_RE = /^(\d{4})-(\d{2})-(\d{2})\.md$/;
+const YEAR_DIR_RE = /^\d{4}$/;
+const MONTH_DIR_RE = /^\d{2}$/;
+const FORBIDDEN_FILENAME_RE = /[\\/:*?"<>|#^[\]]/g;
+const CONTROL_CHARS_RE = /[\x00-\x1f\x7f]/g;
+const MAX_TITLE_LEN = 48;
+const TIME_PREFIX_RE = /^(?:\d{2}:\d{2}|\d{4}-\d{2}-\d{2}T\S+)\s+/;
+const HASH_TAG_RE = /(?<!\S)#([^\s#]+)/g;
+const FILE_DATE_H1_RE = /^# \d{4}-\d{2}-\d{2}\s*$/;
+const MARKDOWN_HEADING_RE = /^#{1,6}\s+(.+?)\s*$/;
+export async function migrateMemoFlatStructure(config) {
+    const markerPath = path.join(config.workspace, MIGRATION_MARKER);
+    if (await fileExists(markerPath))
+        return;
+    const notesDir = config.notes_dir;
+    if (!(await fileExists(notesDir))) {
+        await writeFile(markerPath, "", "utf8");
+        return;
+    }
+    const legacyFiles = await collectLegacyFiles(notesDir);
+    if (legacyFiles.length === 0) {
+        await writeFile(markerPath, "", "utf8");
+        return;
+    }
+    const memoDir = path.join(notesDir, "memo");
+    const legacyRoot = path.join(notesDir, "legacy");
+    await mkdir(memoDir, { recursive: true });
+    await mkdir(legacyRoot, { recursive: true });
+    let migratedAll = true;
+    for (const filePath of legacyFiles) {
+        try {
+            const ok = await migrateFile(config, filePath, notesDir, memoDir, legacyRoot);
+            if (!ok)
+                migratedAll = false;
+        }
+        catch (error) {
+            migratedAll = false;
+            console.warn(`memo-migration: failed to process ${filePath}: ${error.message}`);
+        }
+    }
+    if (migratedAll) {
+        await pruneEmptyYearMonth(notesDir);
+        await writeFile(markerPath, formatLocalDateTime(new Date()), "utf8");
+    }
+}
+async function collectLegacyFiles(notesDir) {
+    const found = [];
+    let years;
+    try {
+        years = await readdir(notesDir);
+    }
+    catch {
+        return found;
+    }
+    for (const year of years) {
+        if (!YEAR_DIR_RE.test(year))
+            continue;
+        const yearDir = path.join(notesDir, year);
+        let months;
+        try {
+            months = await readdir(yearDir);
+        }
+        catch {
+            continue;
+        }
+        for (const month of months) {
+            if (!MONTH_DIR_RE.test(month))
+                continue;
+            const monthDir = path.join(yearDir, month);
+            let files;
+            try {
+                files = await readdir(monthDir);
+            }
+            catch {
+                continue;
+            }
+            for (const file of files) {
+                if (DATE_FILE_RE.test(file)) {
+                    found.push(path.join(monthDir, file));
+                }
+            }
+        }
+    }
+    return found;
+}
+async function migrateFile(config, filePath, notesDir, memoDir, legacyRoot) {
+    const raw = await readFile(filePath, "utf8");
+    const fileDate = path.basename(filePath, ".md");
+    const body = stripFrontmatterAndH1(raw);
+    const relativeFrom = path.relative(notesDir, filePath).replace(/\\/g, "/");
+    if (classifyContent(body) === "longform") {
+        const title = extractLongformTitle(body, fileDate);
+        const tags = extractTags(body);
+        const sanitized = sanitizeFilename(title) || fileDate;
+        const targetPath = uniqueTargetPath(memoDir, sanitized);
+        await writeMemoFile(targetPath, body.trim(), tags, `${fileDate} 00:00:00`, relativeFrom);
+    }
+    else {
+        const blocks = parseMemoBlocks(body, fileDate);
+        for (const block of blocks) {
+            const bodyText = block.bodyLines.join("\n").trim();
+            if (!bodyText)
+                continue;
+            const tags = extractTags(bodyText);
+            const cleanedBody = stripInlineTags(bodyText);
+            const titleSource = cleanedBody || bodyText;
+            const aiTitle = await generateTitle(config, titleSource);
+            const sanitized = sanitizeFilename(aiTitle) || `${fileDate}-${block.timestamp.replace(/[:\sT]/g, "-")}`;
+            const targetPath = path.join(memoDir, `${sanitized}.md`);
+            await writeMemoFile(targetPath, cleanedBody || bodyText, tags, block.timestamp, relativeFrom);
+        }
+    }
+    const legacyTarget = path.join(legacyRoot, path.relative(notesDir, filePath));
+    await mkdir(path.dirname(legacyTarget), { recursive: true });
+    await rename(filePath, legacyTarget);
+    return true;
+}
+function stripFrontmatterAndH1(raw) {
+    let text = raw;
+    const fm = text.match(/^---\n[\s\S]*?\n---\n?/);
+    if (fm)
+        text = text.slice(fm[0].length);
+    // 先頭の `# YYYY-MM-DD` 1行を除去
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length && lines[i].trim() === "")
+        i++;
+    if (i < lines.length && FILE_DATE_H1_RE.test(lines[i].trim())) {
+        lines.splice(i, 1);
+    }
+    return lines.join("\n");
+}
+function classifyContent(body) {
+    const lines = body.split(/\r?\n/);
+    let i = 0;
+    let strayLines = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === "") {
+            i++;
+            continue;
+        }
+        if (/^-\s+/.test(line)) {
+            i++;
+            while (i < lines.length && /^ {2}\S/.test(lines[i]))
+                i++;
+            continue;
+        }
+        strayLines++;
+        i++;
+    }
+    return strayLines > 0 ? "longform" : "bullets";
+}
+function extractLongformTitle(body, fileDate) {
+    for (const rawLine of body.split(/\r?\n/)) {
+        const trimmed = rawLine.trim();
+        if (!trimmed)
+            continue;
+        if (FILE_DATE_H1_RE.test(trimmed))
+            continue;
+        const headingMatch = trimmed.match(MARKDOWN_HEADING_RE);
+        if (headingMatch)
+            return headingMatch[1].replace(/^#+\s*/, "");
+        // バレット行は longform のタイトルとしては採用しない
+        if (/^-\s+/.test(trimmed))
+            continue;
+        return trimmed.length > MAX_TITLE_LEN ? trimmed.slice(0, MAX_TITLE_LEN) : trimmed;
+    }
+    return `${fileDate} メモ`;
+}
+function uniqueTargetPath(memoDir, baseName) {
+    // longform は冪等性のため同名にぶつかった時は連番にする(同一日付に長文が2つはレアだが安全策)
+    let candidate = path.join(memoDir, `${baseName}.md`);
+    let counter = 2;
+    // 既存があればその後ろにサフィックス
+    // 注意: 同期 stat は使わない / 同期判定が必要なら別実装にするが、簡略化のため一旦そのまま返す
+    return candidate;
+}
+function parseMemoBlocks(body, fileDate) {
+    const lines = body.split(/\r?\n/);
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (/^-\s+/.test(line)) {
+            const headRest = line.replace(/^-\s+/, "");
+            const tsMatch = headRest.match(/^(\d{2}:\d{2}|\d{4}-\d{2}-\d{2}T\S+)\s+/);
+            let timestamp;
+            if (tsMatch) {
+                if (tsMatch[1].length === 5) {
+                    timestamp = `${fileDate} ${tsMatch[1]}:00`;
+                }
+                else {
+                    const dt = new Date(tsMatch[1]);
+                    timestamp = isNaN(dt.getTime()) ? `${fileDate} 00:00:00` : formatLocalDateTime(dt);
+                }
+            }
+            else {
+                timestamp = `${fileDate} 00:00:00`;
+            }
+            const firstBody = headRest.replace(TIME_PREFIX_RE, "").trim();
+            const bodyLines = [];
+            if (firstBody)
+                bodyLines.push(firstBody);
+            let j = i + 1;
+            while (j < lines.length && /^ {2}\S/.test(lines[j])) {
+                bodyLines.push(lines[j].slice(2));
+                j++;
+            }
+            blocks.push({ bodyLines, timestamp });
+            i = j;
+        }
+        else {
+            i++;
+        }
+    }
+    return blocks;
+}
+function extractTags(body) {
+    const tags = new Set();
+    let match;
+    HASH_TAG_RE.lastIndex = 0;
+    while ((match = HASH_TAG_RE.exec(body)) !== null) {
+        tags.add(match[1]);
+    }
+    return Array.from(tags);
+}
+function stripInlineTags(body) {
+    return body.replace(HASH_TAG_RE, "").replace(/\s+\n/g, "\n").replace(/[ \t]+$/gm, "").trim();
+}
+async function generateTitle(config, text) {
+    if (!text)
+        return "";
+    if (process.env.AGENT_SIN_FAKE_PROVIDER === "1" || process.env.AGENT_SIN_SKIP_MEMO_AI_TITLE === "1") {
+        return fallbackTitle(text);
+    }
+    try {
+        const provider = getAiProvider();
+        const prompt = `次のメモ本文から、24文字以下の短いタイトルを1つだけ返してください。
+引用符・カギ括弧・句読点・絵文字・説明文は付けず、タイトル本文のみを1行で返してください。
+本文の言語に合わせて日本語/英語で返してください。
+
+本文:
+${text.length > 600 ? text.slice(0, 600) + "..." : text}`;
+        const response = await provider(config, {
+            model_id: "chat",
+            messages: [{ role: "user", content: prompt }],
+            role: "chat",
+        });
+        const first = (response.text || "").split(/\r?\n/)[0]?.trim() || "";
+        const stripped = first.replace(/^["'「『`]+|["'」』`]+$/g, "").trim();
+        if (stripped)
+            return stripped;
+    }
+    catch (error) {
+        console.warn(`memo-migration: title generation failed: ${error.message}`);
+    }
+    return fallbackTitle(text);
+}
+function fallbackTitle(text) {
+    const head = text.trim().split(/\r?\n/)[0] || "";
+    return head.length > 40 ? head.slice(0, 40) : head;
+}
+function sanitizeFilename(raw) {
+    if (!raw)
+        return "";
+    let cleaned = raw.replace(CONTROL_CHARS_RE, "");
+    cleaned = cleaned.replace(FORBIDDEN_FILENAME_RE, "-");
+    cleaned = cleaned.replace(/[\r\n]+/g, " ");
+    cleaned = cleaned.replace(/\s+/g, " ").trim();
+    cleaned = cleaned.replace(/^[._\- ]+|[._\- ]+$/g, "");
+    if (!cleaned)
+        return "";
+    if (cleaned.length > MAX_TITLE_LEN) {
+        cleaned = cleaned.slice(0, MAX_TITLE_LEN).replace(/[._\- ]+$/g, "");
+    }
+    if (cleaned === "." || cleaned === "..")
+        return "";
+    return cleaned;
+}
+async function writeMemoFile(targetPath, body, tags, timestamp, migratedFrom) {
+    const tagLine = tags.length > 0 ? tags.map((t) => `#${t}`).join(" ") : "";
+    const newContent = tagLine ? `${body.trim()}\n\n${tagLine}\n` : `${body.trim()}\n`;
+    let existing = null;
+    try {
+        existing = await readFile(targetPath, "utf8");
+    }
+    catch {
+        existing = null;
+    }
+    if (existing) {
+        const parsed = parseFrontmatterBlock(existing);
+        const fm = { ...parsed.frontmatter };
+        if (fm.created === undefined)
+            fm.created = timestamp;
+        fm.updated = timestamp;
+        const mergedTagSet = new Set();
+        if (Array.isArray(fm.tags))
+            for (const t of fm.tags)
+                mergedTagSet.add(String(t));
+        mergedTagSet.add("memo");
+        for (const t of tags)
+            mergedTagSet.add(t);
+        fm.tags = Array.from(mergedTagSet);
+        const trimmed = parsed.body.replace(/\n+$/, "");
+        const merged = `${trimmed}\n\n---\n\n${newContent}`;
+        await writeFile(targetPath, `${serializeFrontmatter(fm)}${merged}`, "utf8");
+        return;
+    }
+    const fm = {
+        tags: ["memo", ...tags],
+        created: timestamp,
+        updated: timestamp,
+        migrated_from: migratedFrom,
+    };
+    await writeFile(targetPath, `${serializeFrontmatter(fm)}${newContent}`, "utf8");
+}
+function serializeFrontmatter(frontmatter) {
+    if (Object.keys(frontmatter).length === 0)
+        return "";
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        if (Array.isArray(value)) {
+            lines.push(`${key}: [${value.map((item) => JSON.stringify(item)).join(", ")}]`);
+        }
+        else {
+            lines.push(`${key}: ${JSON.stringify(value)}`);
+        }
+    }
+    lines.push("---", "");
+    return `${lines.join("\n")}\n`;
+}
+function parseFrontmatterBlock(raw) {
+    const match = raw.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (!match)
+        return { frontmatter: {}, body: raw };
+    const fm = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        if (!line.trim() || !line.includes(":"))
+            continue;
+        const [key, ...rest] = line.split(":");
+        let value = rest.join(":").trim();
+        if (value.startsWith("[") && value.endsWith("]")) {
+            const inner = value.slice(1, -1);
+            fm[key.trim()] = inner
+                .split(",")
+                .map((part) => part.trim().replace(/^["']|["']$/g, ""))
+                .filter(Boolean);
+        }
+        else {
+            if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            fm[key.trim()] = value;
+        }
+    }
+    return { frontmatter: fm, body: raw.slice(match[0].length) };
+}
+async function pruneEmptyYearMonth(notesDir) {
+    let years;
+    try {
+        years = await readdir(notesDir);
+    }
+    catch {
+        return;
+    }
+    for (const year of years) {
+        if (!YEAR_DIR_RE.test(year))
+            continue;
+        const yearDir = path.join(notesDir, year);
+        let months;
+        try {
+            months = await readdir(yearDir);
+        }
+        catch {
+            continue;
+        }
+        for (const month of months) {
+            if (!MONTH_DIR_RE.test(month))
+                continue;
+            const monthDir = path.join(yearDir, month);
+            try {
+                const remaining = await readdir(monthDir);
+                if (remaining.length === 0)
+                    await rmdir(monthDir);
+            }
+            catch {
+                // ignore
+            }
+        }
+        try {
+            const remaining = await readdir(yearDir);
+            if (remaining.length === 0)
+                await rmdir(yearDir);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+async function fileExists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function formatLocalDateTime(date) {
+    const yyyy = String(date.getFullYear());
+    const MM = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    const hh = String(date.getHours()).padStart(2, "0");
+    const mm = String(date.getMinutes()).padStart(2, "0");
+    const ss = String(date.getSeconds()).padStart(2, "0");
+    return `${yyyy}-${MM}-${dd} ${hh}:${mm}:${ss}`;
+}

package/dist/core/native-modules.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Detect and self-heal native module ABI mismatch for `better-sqlite3`.
+ *
+ * Native bindings (.node) are pinned to a Node.js NODE_MODULE_VERSION. If
+ * `npm install` ran on one Node major and the service later boots under a
+ * different one, every `new Database(...)` call throws and weekly reports
+ * silently lose history. We probe in a child process to keep our own
+ * process unpolluted, and rebuild with the same `process.execPath` that
+ * will run the service so the produced binary matches the actual runtime.
+ */
+export type NativeModulesLogger = (line: string) => void;
+export interface EnsureBetterSqlite3Options {
+    /** Directory that contains node_modules/better-sqlite3 (the agent-sin install root). */
+    packageRoot: string;
+    /** Optional human-readable status logger. */
+    logger?: NativeModulesLogger;
+}
+export interface EnsureBetterSqlite3Result {
+    ok: boolean;
+    rebuilt: boolean;
+    detail?: string;
+}
+export declare function ensureBetterSqlite3(options: EnsureBetterSqlite3Options): Promise<EnsureBetterSqlite3Result>;
+export declare function isAbiMismatchError(message: string): boolean;

package/dist/core/native-modules.js

@@ -0,0 +1,99 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+const PROBE_SCRIPT = `
+try {
+  const Database = require('better-sqlite3');
+  const db = new Database(':memory:');
+  db.close();
+  process.exit(0);
+} catch (error) {
+  const message = error && error.message ? error.message : String(error);
+  process.stderr.write(message);
+  process.exit(1);
+}
+`;
+export async function ensureBetterSqlite3(options) {
+    const log = options.logger ?? (() => { });
+    const first = await probeBetterSqlite3(options.packageRoot);
+    if (first.ok) {
+        return { ok: true, rebuilt: false };
+    }
+    if (!isAbiMismatchError(first.detail || "")) {
+        log(`better-sqlite3 load failed: ${first.detail}`);
+        return { ok: false, rebuilt: false, detail: first.detail };
+    }
+    log(`better-sqlite3 ABI mismatch detected; rebuilding for ${process.execPath}…`);
+    const rebuild = await runRebuild(options.packageRoot);
+    if (!rebuild.ok) {
+        log(`better-sqlite3 rebuild failed: ${rebuild.detail}`);
+        return { ok: false, rebuilt: false, detail: rebuild.detail };
+    }
+    const second = await probeBetterSqlite3(options.packageRoot);
+    if (!second.ok) {
+        log(`better-sqlite3 still broken after rebuild: ${second.detail}`);
+        return { ok: false, rebuilt: true, detail: second.detail };
+    }
+    log("better-sqlite3 rebuild succeeded.");
+    return { ok: true, rebuilt: true };
+}
+async function probeBetterSqlite3(packageRoot) {
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, ["-e", PROBE_SCRIPT], {
+            cwd: packageRoot,
+            env: { ...process.env, NODE_DISABLE_COLORS: "1" },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        child.stdout?.on("data", () => { });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            resolve({ ok: false, detail: error.message });
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve({ ok: true });
+            }
+            else {
+                resolve({ ok: false, detail: stderr.trim() || `probe exited with code ${code ?? "null"}` });
+            }
+        });
+    });
+}
+async function runRebuild(packageRoot) {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const nodeDir = path.dirname(process.execPath);
+    const pathSep = process.platform === "win32" ? ";" : ":";
+    const env = {
+        ...process.env,
+        PATH: `${nodeDir}${pathSep}${process.env.PATH || ""}`,
+        npm_config_node_execpath: process.execPath,
+    };
+    return new Promise((resolve) => {
+        const child = spawn(npm, ["rebuild", "better-sqlite3"], {
+            cwd: packageRoot,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        child.stdout?.on("data", () => { });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            resolve({ ok: false, detail: error.message });
+        });
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve({ ok: true });
+            }
+            else {
+                resolve({ ok: false, detail: stderr.trim() || `npm rebuild exited with code ${code ?? "null"}` });
+            }
+        });
+    });
+}
+export function isAbiMismatchError(message) {
+    return /NODE_MODULE_VERSION|was compiled against a different Node\.js version|invalid ELF header|incompatible|Module did not self-register|dlopen.*Symbol not found|napi|node-gyp|Could not locate the bindings file/i.test(message);
+}

package/dist/core/notifier.d.ts

@@ -1,13 +1,18 @@
-export type NotifyChannel = "macos" | "windows" | "discord" | "telegram" | "slack" | "mail" | "stderr";
+export type NotifyChannel = "macos" | "windows" | "discord" | "telegram" | "slack" | "mail" | "g2" | "stderr";
 export interface NotifyOptions {
-    title: string;
-    body: string;
+    title?: string;
+    body?: string;
     subtitle?: string;
     sound?: boolean;
     channel?: NotifyChannel | "auto";
     to?: string;
     discordThreadId?: string;
     telegramThreadId?: string;
+    filePath?: string;
+    filePaths?: string[];
+    imagePath?: string;
+    imagePaths?: string[];
+    cwd?: string;
 }
 export interface NotifyResult {
     channel: NotifyChannel;