agent-sin 0.1.11 → 0.1.15

package/dist/core/output-writer.js

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import YAML from "yaml";
 import { l } from "./i18n.js";
 export async function writeSkillOutputs(config, manifest, result, date = new Date()) {
     const saved = [];
@@ -11,22 +12,24 @@ export async function writeSkillOutputs(config, manifest, result, date = new Dat
         if (output.type !== "markdown") {
             throw new Error(l(`Unsupported output type: ${output.type}`, `未対応の出力形式です: ${output.type}`));
         }
-        const file = resolveOutputFile(config, output, date);
+        const overrideFilename = sanitizeOverrideFilename(value.filename);
+        const file = resolveOutputFile(config, output, date, overrideFilename);
         assertAllowedOutputPath(config, file);
         await writeMarkdown(file, output, value, date);
+        const mode = resolveMergeMode(output);
         saved.push({
             id: output.id,
             type: output.type,
             path: file,
-            append: output.append ?? false,
+            append: mode !== "overwrite",
             show_saved: output.show_saved !== false,
         });
     }
     return saved;
 }
-export function resolveOutputFile(config, output, date) {
+export function resolveOutputFile(config, output, date, overrideFilename) {
     const renderedDir = renderTemplate(output.path, date);
-    const renderedFilename = renderTemplate(output.filename, date);
+    const renderedFilename = overrideFilename || renderTemplate(output.filename, date);
     const normalized = renderedDir.replace(/^\.?\//, "");
     if (normalized === "notes" || normalized.startsWith("notes/")) {
         const rest = normalized.replace(/^notes\/?/, "");
@@ -37,27 +40,64 @@ export function resolveOutputFile(config, output, date) {
     }
     return path.join(config.workspace, normalized, renderedFilename);
 }
-export function renderTemplate(template, date) {
+export function renderTemplate(template, date, vars = {}) {
     const yyyy = String(date.getFullYear());
     const MM = String(date.getMonth() + 1).padStart(2, "0");
     const dd = String(date.getDate()).padStart(2, "0");
     const isoDate = `${yyyy}-${MM}-${dd}`;
-    return template
+    let out = template
         .replaceAll("{{yyyy}}", yyyy)
         .replaceAll("{{MM}}", MM)
         .replaceAll("{{dd}}", dd)
         .replaceAll("{{date}}", isoDate)
         .replaceAll("{{datetime}}", date.toISOString());
+    for (const [key, val] of Object.entries(vars)) {
+        out = out.replaceAll(`{{${key}}}`, val);
+    }
+    return out;
+}
+function sanitizeOverrideFilename(name) {
+    if (typeof name !== "string")
+        return undefined;
+    let cleaned = name.replace(/\0/g, "").replace(/[\\/]/g, "-").trim();
+    cleaned = cleaned.replace(/^\.+/, "");
+    if (!cleaned || cleaned === "." || cleaned === "..")
+        return undefined;
+    if (path.isAbsolute(cleaned))
+        cleaned = path.basename(cleaned);
+    return cleaned;
+}
+function resolveMergeMode(output) {
+    if (output.merge_mode)
+        return output.merge_mode;
+    if (output.append)
+        return "append";
+    return "overwrite";
 }
 async function writeMarkdown(file, output, value, date) {
     const content = value.content || "";
     await mkdir(path.dirname(file), { recursive: true });
-    if (output.append) {
+    const mode = resolveMergeMode(output);
+    if (mode === "append") {
         const existing = await readTextIfExists(file);
         const prefix = existing ? "" : initialMarkdown(value.frontmatter, date);
         await writeFile(file, `${prefix}${existing}${ensureTrailingNewline(content)}`, "utf8");
         return;
     }
+    if (mode === "update_or_append") {
+        const existing = await readTextIfExists(file);
+        if (!existing) {
+            const fm = withCreatedUpdated(value.frontmatter, date, date);
+            await writeFile(file, `${initialFrontmatter(fm)}${ensureTrailingNewline(content)}`, "utf8");
+            return;
+        }
+        const parsed = parseFrontmatterBlock(existing);
+        const mergedFm = mergeFrontmatterForUpdate(parsed.frontmatter, value.frontmatter, date);
+        const trimmedBody = parsed.body.replace(/\n+$/, "");
+        const newBody = `${trimmedBody}\n\n---\n\n${ensureTrailingNewline(content)}`;
+        await writeFile(file, `${initialFrontmatter(mergedFm)}${newBody}`, "utf8");
+        return;
+    }
     await writeFile(file, `${initialFrontmatter(value.frontmatter)}${content}`, "utf8");
 }
 function initialMarkdown(frontmatter, date) {
@@ -80,6 +120,67 @@ function initialFrontmatter(frontmatter) {
     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 };
+    }
+    let parsed = {};
+    try {
+        const obj = YAML.parse(match[1] || "");
+        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+            parsed = obj;
+        }
+    }
+    catch {
+        parsed = {};
+    }
+    return { frontmatter: parsed, body: raw.slice(match[0].length) };
+}
+function mergeFrontmatterForUpdate(existing, incoming, date) {
+    const out = { ...existing };
+    if (incoming) {
+        for (const [key, val] of Object.entries(incoming)) {
+            if (key === "created") {
+                if (out.created === undefined)
+                    out.created = val ?? formatLocalDateTime(date);
+                continue;
+            }
+            if (key === "updated")
+                continue;
+            if (key === "tags" && Array.isArray(val) && Array.isArray(out.tags)) {
+                const merged = new Set();
+                for (const item of out.tags)
+                    merged.add(String(item));
+                for (const item of val)
+                    merged.add(String(item));
+                out.tags = Array.from(merged);
+                continue;
+            }
+            out[key] = val;
+        }
+    }
+    if (out.created === undefined)
+        out.created = formatLocalDateTime(date);
+    out.updated = formatLocalDateTime(date);
+    return out;
+}
+function withCreatedUpdated(frontmatter, createdFallback, updated) {
+    const out = { ...(frontmatter || {}) };
+    if (out.created === undefined)
+        out.created = formatLocalDateTime(createdFallback);
+    out.updated = formatLocalDateTime(updated);
+    return out;
+}
+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}`;
+}
 function ensureTrailingNewline(value) {
     return value.endsWith("\n") ? value : `${value}\n`;
 }

package/dist/core/profile-memory.js

@@ -86,7 +86,12 @@ export async function appendProfileMemory(config, target, text, date = new Date(
     }
     await ensureProfileMemoryFiles(config);
     const file = profileMemoryPath(config, target);
-    await appendFile(file, formatProfileEntry(value, date), "utf8");
+    if (target === "memory") {
+        await appendMemoryEntry(file, formatProfileEntry(value, date));
+    }
+    else {
+        await appendFile(file, formatProfileEntry(value, date), "utf8");
+    }
     return file;
 }
 export function parseProfileMemoryTarget(value) {
@@ -121,6 +126,22 @@ function profileMemoryPaths(config) {
         memory: profileMemoryPath(config, "memory"),
     };
 }
+async function appendMemoryEntry(file, entry) {
+    const original = await readFile(file, "utf8");
+    const index = recentTopicsSectionStart(original);
+    if (index < 0) {
+        await appendFile(file, entry, "utf8");
+        return;
+    }
+    const before = original.slice(0, index).replace(/\s+$/, "");
+    const after = original.slice(index).replace(/^\s+/, "");
+    const next = `${before}${entry}\n${after}`;
+    await writeFile(file, next, "utf8");
+}
+function recentTopicsSectionStart(text) {
+    const match = /^##\s+(?:Recent 7-day topics|直近1週間のトピック)\s*$/im.exec(text);
+    return match ? match.index : -1;
+}
 async function writeIfMissing(file, content) {
     try {
         await stat(file);

package/dist/core/runtime.d.ts

@@ -10,6 +10,8 @@ export interface RunSkillResponse {
     log_path: string;
     memory_path?: string;
     attempts: number;
+    /** ctx.log entries emitted during the run — surfaced so callers can see warn/error. */
+    ctx_logs?: SkillLogEntry[];
 }
 export interface RunSkillOptions {
     /** @deprecated Approval gating was removed; field kept for API compatibility. */

package/dist/core/runtime.js

@@ -1,8 +1,9 @@
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import { appendEventLog, createRunId, writeRunLog } from "./logger.js";
 import { loadSkillMemory, saveSkillMemoryUpdates } from "./memory.js";
 import { writeSkillOutputs } from "./output-writer.js";
-import { findSkillManifest } from "./skill-registry.js";
+import { builtinSkillsDir, findSkillManifest } from "./skill-registry.js";
 import { validateSkillArgs } from "./input-schema.js";
 import { loadDotenv } from "./secrets.js";
 import { ensureProfileMemoryFiles } from "./profile-memory.js";
@@ -34,6 +35,8 @@ export async function runSkill(config, skillId, args, options = {}) {
     const runId = createRunId();
     const started = new Date();
     const memory = await loadSkillMemory(config, manifest);
+    const skillOutputDir = path.join(config.skill_outputs_dir, manifest.id);
+    await mkdir(skillOutputDir, { recursive: true });
     const input = {
         args,
         trigger: {
@@ -47,6 +50,10 @@ export async function runSkill(config, skillId, args, options = {}) {
             memory_dir: config.memory_dir,
             index_dir: config.index_dir,
             logs_dir: config.logs_dir,
+            skills_dir: config.skills_dir,
+            builtin_skills_dir: builtinSkillsDir(),
+            skill_output_dir: skillOutputDir,
+            skillOutputDir,
             locale: detectLocale(),
         },
         memory,
@@ -103,6 +110,7 @@ export async function runSkill(config, skillId, args, options = {}) {
                     log_path: logPath,
                     memory_path: memoryPath,
                     attempts,
+                    ctx_logs: skillLogs.length > 0 ? skillLogs : undefined,
                 };
             }
             catch (error) {

package/dist/core/secrets.d.ts

@@ -13,6 +13,10 @@ export declare function upsertDotenv(workspace: string, entries: Array<{
 }>): Promise<{
     path: string;
 }>;
+export declare function removeFromDotenv(workspace: string, keys: string[]): Promise<{
+    path: string;
+    removed: string[];
+}>;
 export interface ApiKeySource {
     provider: string;
     envVar: string;

package/dist/core/secrets.js

@@ -132,6 +132,40 @@ export async function upsertDotenv(workspace, entries) {
     await writeFile(file, next, { mode: 0o600 });
     return { path: file };
 }
+export async function removeFromDotenv(workspace, keys) {
+    const file = path.join(workspace, ".env");
+    let existing = "";
+    try {
+        existing = await readFile(file, "utf8");
+    }
+    catch {
+        return { path: file, removed: [] };
+    }
+    const lines = existing.split(/\r?\n/);
+    const targets = new Set(keys);
+    const removed = [];
+    const keptLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            keptLines.push(line);
+            continue;
+        }
+        const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+        if (match && targets.has(match[1])) {
+            if (!removed.includes(match[1]))
+                removed.push(match[1]);
+            delete process.env[match[1]];
+            continue;
+        }
+        keptLines.push(line);
+    }
+    let next = keptLines.join("\n");
+    if (!next.endsWith("\n"))
+        next = `${next}\n`;
+    await writeFile(file, next, { mode: 0o600 });
+    return { path: file, removed };
+}
 function formatDotenvValue(value) {
     if (/[\s"'#]/.test(value) || value === "") {
         const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');

package/dist/core/skill-history.d.ts

@@ -0,0 +1,44 @@
+import type { AppConfig } from "./config.js";
+import type { SkillManifest } from "./skill-registry.js";
+/**
+ * Per-skill structured log backed by SQLite. The skill keeps reading/writing
+ * via `ctx.history.append/list/read`; this module is the only place that
+ * touches the DB and the on-disk layout.
+ *
+ *   ~/.agent-sin/data/<skill-id>.db   one file per skill, schema below
+ *
+ *   entries(id PK, time, meta JSON, content TEXT)
+ *
+ * Bulky structured fields belong in `meta` (JSON). Human-readable summaries
+ * belong in `content`. Reports that the user reads back in Obsidian are a
+ * separate concern handled by skill manifests' `outputs:` block.
+ */
+export interface SkillHistoryEntry {
+    time: string;
+    meta: Record<string, unknown>;
+    content: string;
+}
+export interface AppendHistoryArgs {
+    time?: string | Date;
+    meta?: Record<string, unknown>;
+    content: string;
+    /**
+     * When true, replace an existing row that shares the same `meta.id`. The
+     * caller must supply `meta.id`. When the id is unknown, a fresh row is
+     * always inserted.
+     */
+    replace?: boolean;
+}
+export interface HistoryRangeOptions {
+    from?: string | Date;
+    to?: string | Date;
+    limit?: number;
+}
+export declare function skillHistoryDataDir(config: AppConfig): string;
+export declare function skillHistoryDbPath(config: AppConfig, skillId: string): string;
+export declare function appendSkillHistory(config: AppConfig, manifest: SkillManifest, args: AppendHistoryArgs): Promise<{
+    path: string;
+    id: string;
+}>;
+export declare function listSkillHistory(config: AppConfig, manifest: SkillManifest, options?: HistoryRangeOptions): Promise<SkillHistoryEntry[]>;
+export declare function readSkillHistoryRaw(config: AppConfig, manifest: SkillManifest, options?: HistoryRangeOptions): Promise<string>;

package/dist/core/skill-history.js

@@ -0,0 +1,329 @@
+import { mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import Database from "better-sqlite3";
+import YAML from "yaml";
+import { l } from "./i18n.js";
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS entries (
+    id      TEXT PRIMARY KEY,
+    time    TEXT NOT NULL,
+    meta    TEXT NOT NULL DEFAULT '{}',
+    content TEXT NOT NULL DEFAULT ''
+  );
+  CREATE INDEX IF NOT EXISTS entries_time_idx ON entries (time);
+  CREATE TABLE IF NOT EXISTS _meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT
+  );
+`;
+export function skillHistoryDataDir(config) {
+    return path.join(config.workspace, "data");
+}
+export function skillHistoryDbPath(config, skillId) {
+    return path.join(skillHistoryDataDir(config), `${safeSkillSegment(skillId)}.db`);
+}
+export async function appendSkillHistory(config, manifest, args) {
+    if (manifest.history?.write !== true) {
+        throw new Error(l("History write is not allowed for this skill", "このスキルでは履歴の書き込みが許可されていません"));
+    }
+    const db = await openSkillDb(config, manifest.id);
+    try {
+        const time = toDate(args.time) ?? new Date();
+        const meta = sanitizeMeta(args.meta);
+        const explicitId = typeof meta.id === "string" && meta.id ? meta.id : undefined;
+        const content = args.content.trim();
+        if (args.replace === true) {
+            if (!explicitId) {
+                throw new Error(l("history.append replace requires meta.id", "history.append replace には meta.id が必要です"));
+            }
+            const row = {
+                id: explicitId,
+                time: time.toISOString(),
+                meta: JSON.stringify(meta),
+                content,
+            };
+            db.prepare("INSERT INTO entries(id, time, meta, content) VALUES (@id, @time, @meta, @content) " +
+                "ON CONFLICT(id) DO UPDATE SET time=excluded.time, meta=excluded.meta, content=excluded.content").run(row);
+            return { path: skillHistoryDbPath(config, manifest.id), id: explicitId };
+        }
+        const id = explicitId ?? generateEntryId(time);
+        if (!meta.id)
+            meta.id = id;
+        const row = {
+            id,
+            time: time.toISOString(),
+            meta: JSON.stringify(meta),
+            content,
+        };
+        db.prepare("INSERT OR REPLACE INTO entries(id, time, meta, content) VALUES (@id, @time, @meta, @content)").run(row);
+        return { path: skillHistoryDbPath(config, manifest.id), id };
+    }
+    finally {
+        db.close();
+    }
+}
+export async function listSkillHistory(config, manifest, options = {}) {
+    if (manifest.history?.read !== true) {
+        throw new Error(l("History read is not allowed for this skill", "このスキルでは履歴の読み取りが許可されていません"));
+    }
+    const db = await openSkillDb(config, manifest.id);
+    try {
+        const { sql, params } = buildSelect(options);
+        const rows = db.prepare(sql).all(params);
+        const entries = [];
+        for (const row of rows) {
+            let meta = {};
+            try {
+                const parsed = JSON.parse(row.meta);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    meta = parsed;
+                }
+            }
+            catch {
+                meta = {};
+            }
+            entries.push({ time: row.time, meta, content: row.content });
+        }
+        return entries;
+    }
+    finally {
+        db.close();
+    }
+}
+export async function readSkillHistoryRaw(config, manifest, options = {}) {
+    const entries = await listSkillHistory(config, manifest, options);
+    return entries
+        .map((entry) => {
+        const metaLine = JSON.stringify(entry.meta);
+        return `---\ntime: ${entry.time}\nmeta: ${metaLine}\n---\n${entry.content}`.trim();
+    })
+        .join("\n\n");
+}
+function buildSelect(options) {
+    const params = {};
+    const where = [];
+    const from = toDate(options.from);
+    const to = toDate(options.to);
+    if (from) {
+        where.push("time >= @from");
+        params.from = startOfDay(from).toISOString();
+    }
+    if (to) {
+        where.push("time <= @to");
+        params.to = endOfDay(to).toISOString();
+    }
+    let sql = "SELECT time, meta, content FROM entries";
+    if (where.length > 0)
+        sql += " WHERE " + where.join(" AND ");
+    sql += " ORDER BY time ASC";
+    if (typeof options.limit === "number" && options.limit >= 0) {
+        sql += " LIMIT @limit";
+        params.limit = options.limit;
+    }
+    return { sql, params };
+}
+function sanitizeMeta(meta) {
+    if (!meta || typeof meta !== "object" || Array.isArray(meta))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(meta)) {
+        if (value === undefined)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function generateEntryId(time) {
+    const stamp = time.toISOString().replace(/[^0-9]/g, "").slice(0, 14);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `${stamp}-${rand}`;
+}
+function startOfDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0);
+}
+function endOfDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+}
+function toDate(value) {
+    if (!value)
+        return undefined;
+    if (value instanceof Date)
+        return value;
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+function safeSkillSegment(value) {
+    if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+        throw new Error(l(`Invalid skill id for history path: ${value}`, `履歴のパスに不正なスキルIDが含まれています: ${value}`));
+    }
+    return value;
+}
+async function openSkillDb(config, skillId) {
+    const dir = skillHistoryDataDir(config);
+    await mkdir(dir, { recursive: true });
+    const file = skillHistoryDbPath(config, skillId);
+    const db = new Database(file);
+    db.pragma("journal_mode = WAL");
+    db.exec(SCHEMA);
+    await migrateLegacyMarkdown(config, skillId, db);
+    return db;
+}
+/**
+ * One-time migration from the original Markdown layout
+ * (`notes/<skill-id>/{{yyyy}}/{{MM}}/<date>.md`) into the new SQLite store.
+ * Parses each entry block, inserts a row keyed by meta.id when present
+ * (or a freshly generated id otherwise), then archives the original notes
+ * directory next to itself as `<dir>.legacy-md`.
+ */
+async function migrateLegacyMarkdown(config, skillId, db) {
+    const flag = db.prepare("SELECT value FROM _meta WHERE key = 'legacy_md_migrated' LIMIT 1").get();
+    if (flag)
+        return;
+    const markDone = db.prepare("INSERT OR REPLACE INTO _meta(key, value) VALUES (?, ?)");
+    const legacyRoot = path.join(config.notes_dir, safeSkillSegment(skillId));
+    let stats;
+    try {
+        stats = await stat(legacyRoot);
+    }
+    catch {
+        markDone.run("legacy_md_migrated", new Date().toISOString());
+        return;
+    }
+    if (!stats.isDirectory()) {
+        markDone.run("legacy_md_migrated", new Date().toISOString());
+        return;
+    }
+    const files = [];
+    await walkMarkdown(legacyRoot, files);
+    const insertSql = "INSERT INTO entries(id, time, meta, content) VALUES (@id, @time, @meta, @content) " +
+        "ON CONFLICT(id) DO UPDATE SET time=excluded.time, meta=excluded.meta, content=excluded.content";
+    const stmt = db.prepare(insertSql);
+    const tx = db.transaction((rows) => {
+        for (const row of rows)
+            stmt.run(row);
+    });
+    const rows = [];
+    for (const file of files) {
+        const raw = await readFile(file, "utf8");
+        for (const entry of parseLegacyEntries(raw, file)) {
+            const id = typeof entry.meta.id === "string" && entry.meta.id ? entry.meta.id : generateEntryId(new Date(entry.time));
+            if (!entry.meta.id)
+                entry.meta.id = id;
+            rows.push({
+                id,
+                time: entry.time,
+                meta: JSON.stringify(entry.meta),
+                content: entry.content,
+            });
+        }
+    }
+    if (rows.length > 0)
+        tx(rows);
+    markDone.run("legacy_md_migrated", JSON.stringify({ at: new Date().toISOString(), files: files.length, entries: rows.length }));
+    await rm(legacyRoot, { recursive: true, force: true });
+}
+async function walkMarkdown(dir, out) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkMarkdown(full, out);
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".md") && /^\d{4}-\d{2}-\d{2}\.md$/.test(entry.name)) {
+            out.push(full);
+        }
+    }
+}
+function parseLegacyEntries(raw, file) {
+    const body = stripLegacyFrontmatter(raw);
+    const entries = [];
+    const sectionRegex = /(^|\n)##\s+(\d{1,2}:\d{2})\b[^\n]*\n([\s\S]*?)(?=\n##\s+\d{1,2}:\d{2}\b|$)/g;
+    let match;
+    const fileDate = inferLegacyFileDate(file);
+    while ((match = sectionRegex.exec(body)) !== null) {
+        const headerTime = match[2];
+        const blockBody = match[3];
+        const { meta, content } = splitLegacyMetaAndContent(blockBody);
+        const isoTime = extractLegacyMetaTime(meta) ?? combineDateTime(fileDate, headerTime);
+        delete meta.time;
+        entries.push({ time: isoTime, meta, content });
+    }
+    return entries;
+}
+function splitLegacyMetaAndContent(blockBody) {
+    const lines = blockBody.replace(/^\n/, "").split("\n");
+    const yamlMetaLines = [];
+    const hiddenMeta = {};
+    let i = 0;
+    for (; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.trim() === "")
+            break;
+        const hiddenMatch = line.match(/^<!--\s+([A-Za-z0-9_][A-Za-z0-9_\-]*)\s*:\s*([\s\S]*?)\s*-->\s*$/);
+        if (hiddenMatch) {
+            const key = hiddenMatch[1];
+            const rawValue = hiddenMatch[2];
+            try {
+                hiddenMeta[key] = YAML.parse(rawValue);
+            }
+            catch {
+                hiddenMeta[key] = rawValue;
+            }
+            continue;
+        }
+        if (!/^[A-Za-z0-9_][A-Za-z0-9_\-]*\s*:/.test(line))
+            break;
+        yamlMetaLines.push(line);
+    }
+    const contentLines = i < lines.length ? lines.slice(i + 1) : [];
+    let meta = {};
+    if (yamlMetaLines.length > 0) {
+        try {
+            const parsed = YAML.parse(yamlMetaLines.join("\n"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                meta = parsed;
+            }
+        }
+        catch {
+            meta = {};
+        }
+    }
+    return { meta: { ...meta, ...hiddenMeta }, content: contentLines.join("\n").trim() };
+}
+function stripLegacyFrontmatter(raw) {
+    if (!raw.startsWith("---\n"))
+        return raw;
+    const end = raw.indexOf("\n---", 4);
+    if (end < 0)
+        return raw;
+    const after = raw.slice(end + 4);
+    return after.replace(/^\n/, "");
+}
+function extractLegacyMetaTime(meta) {
+    const rawValue = meta.time;
+    if (typeof rawValue === "string" && rawValue)
+        return rawValue;
+    if (rawValue instanceof Date && !Number.isNaN(rawValue.getTime()))
+        return rawValue.toISOString();
+    return undefined;
+}
+function inferLegacyFileDate(file) {
+    const match = path.basename(file).match(/^(\d{4})-(\d{2})-(\d{2})\.md$/);
+    if (!match)
+        return new Date();
+    return new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+}
+function combineDateTime(date, hhmm) {
+    const [hh, mm] = hhmm.split(":").map((part) => Number(part));
+    const merged = new Date(date.getFullYear(), date.getMonth(), date.getDate(), hh || 0, mm || 0);
+    return merged.toISOString();
+}