agim-cli 1.0.1

package/dist/core/memos.d.ts

@@ -0,0 +1,163 @@
+/** UTC+8 wall-clock as `YYYY-MM-DD HH:MM:SS` — matches SQLite's `datetime()`
+ *  output shape so cross-source comparisons are well-defined. */
+export declare function nowSqliteLocal(): string;
+/** Convert an absolute Date (or ms) to the local-storage shape. */
+export declare function toSqliteLocal(d: Date | number): string;
+/** Normalize whatever the agent passes for `when_at` into our storage shape.
+ *  Accepts: bare ISO (assumed already local), ISO with `Z` or `±HH:MM` offset,
+ *  or already-normalized "YYYY-MM-DD HH:MM:SS". Output: "YYYY-MM-DD HH:MM:SS"
+ *  in UTC+8. Falls through unchanged on parse failure rather than throwing
+ *  so an agent typo doesn't kill the save. */
+export declare function normalizeWhenAt(s: string | null | undefined): string | null;
+export type MemoSource = 'manual' | 'agent' | 'geocoded' | 'browser';
+export interface Memo {
+    id: number;
+    platform: string;
+    channel_id: string;
+    thread_id: string;
+    user_id: string;
+    what: string;
+    who: string | null;
+    when_at: string | null;
+    when_text: string | null;
+    where_lat: number | null;
+    where_lng: number | null;
+    where_label: string | null;
+    how: string | null;
+    why: string | null;
+    /** Free-text full intent — preserves the user's complete phrasing when
+     *  `what` is an extracted short noun. Optional; null when unset. */
+    memo: string | null;
+    expires_at: string | null;
+    source: MemoSource;
+    created_at: string;
+    updated_at: string;
+}
+export interface OwnerOpts {
+    /** Scope reads/writes/deletes to this user. Empty = unrestricted (tests
+     *  / non-IM callers only). Production calls always pass userId. */
+    userId?: string;
+}
+export interface CreateMemoInput {
+    platform: string;
+    channelId: string;
+    threadId: string;
+    userId?: string;
+    what: string;
+    who?: string | null;
+    whenAt?: string | null;
+    whenText?: string | null;
+    whereLat?: number | null;
+    whereLng?: number | null;
+    whereLabel?: string | null;
+    how?: string | null;
+    why?: string | null;
+    /** Free-text full intent — preserve user's complete phrasing when `what`
+     *  is a shorter extracted noun. Optional. */
+    memo?: string | null;
+    expiresAt?: string | null;
+    source?: MemoSource;
+}
+export declare function createMemo(input: CreateMemoInput): number;
+export interface UpdateMemoInput {
+    what?: string;
+    who?: string | null;
+    whenAt?: string | null;
+    whenText?: string | null;
+    whereLat?: number | null;
+    whereLng?: number | null;
+    whereLabel?: string | null;
+    how?: string | null;
+    why?: string | null;
+    memo?: string | null;
+    expiresAt?: string | null;
+}
+/** Patch-style update — only fields explicitly present in the input are
+ *  written. Pass `null` to clear a field (vs `undefined` = leave alone). */
+export declare function updateMemo(id: number, input: UpdateMemoInput, opts?: OwnerOpts): boolean;
+export declare function getMemo(id: number, opts?: OwnerOpts): Memo | null;
+export declare function deleteMemo(id: number, opts?: OwnerOpts): boolean;
+export interface SearchOpts extends OwnerOpts {
+    /** Free-text — matched as `LIKE %query%` against what / who / where_label /
+     *  how / why / when_text. Single token; no AND splitting. */
+    query?: string;
+    /** LIKE filter on `who` only. */
+    who?: string;
+    /** LIKE filter on `what` only. */
+    what?: string;
+    /** When true, filter to rows where where_lat IS NOT NULL. */
+    hasLocation?: boolean;
+    /** ISO range on `when_at` (or fall back to `created_at` when when_at is null). */
+    whenAfter?: string;
+    whenBefore?: string;
+    /** When true, include expired rows in the result. Default: exclude. */
+    includeExpired?: boolean;
+    limit?: number;
+}
+/**
+ * Search memos. All filters are AND-combined. Empty filter set returns the
+ * most recent memos (= same as listMemos).
+ *
+ * Sort: `created_at DESC` (newest first). Future: relevance score.
+ *
+ * Wildcard escaping: SQL LIKE `%` and `_` in the query become literal chars
+ * via `LIKE ESCAPE '\\'` — the user's question-mark or percent doesn't blow
+ * the search wide open.
+ */
+export declare function searchMemos(opts?: SearchOpts): Memo[];
+/** Recent memos for this user. Convenience wrapper around searchMemos. */
+export declare function listMemos(opts?: OwnerOpts & {
+    limit?: number;
+}): Memo[];
+export declare function sweepExpired(): number;
+export declare function startSweepTimer(): void;
+export declare function stopSweepTimer(): void;
+export declare function closeMemosDb(): void;
+export declare function parseCoordPair(input: string): {
+    lat: number;
+    lng: number;
+} | null;
+export declare function stripCoordPrefix(input: string): string;
+export type GeocodeOutcome = {
+    ok: true;
+    lat: number;
+    lng: number;
+    formattedAddress: string;
+} | {
+    ok: false;
+    reason: 'no_key' | 'quota' | 'signature' | 'not_found' | 'http' | 'unknown';
+    status?: number;
+    message?: string;
+};
+export declare function geocodeAddress(address: string): Promise<GeocodeOutcome>;
+export declare function isGeocodingAvailable(): boolean;
+export declare function wgs84ToGcj02(lat: number, lng: number): {
+    lat: number;
+    lng: number;
+};
+/**
+ * Reverse of wgs84ToGcj02. Useful when an upstream gives us GCJ-02 coords
+ * but our DB convention is WGS-84.
+ *
+ * Common case: iOS Core Location in China returns GCJ-02 by design (Apple
+ * applies the offset to comply with PRC regulations). Telegram on a Chinese
+ * iPhone forwards exactly those coords. Without this reverse, the values
+ * get re-offset when we build amap/baidu URLs → marker lands 500m–1km off.
+ *
+ * Math: GCJ→WGS doesn't have a closed-form inverse, so we use the standard
+ * Newton's-method-style refinement — compute the forward offset at the
+ * GCJ point, subtract to get a candidate WGS point, then iterate. Three
+ * passes converge to sub-meter precision for any reasonable input.
+ */
+export declare function gcj02ToWgs84(lat: number, lng: number): {
+    lat: number;
+    lng: number;
+};
+export interface MapUrls {
+    baidu: string;
+    amap: string;
+    google: string;
+}
+export declare function mapUrls(lat: number, lng: number, label?: string, addr?: string): MapUrls;
+export declare function mapUrl(lat: number, lng: number, label?: string, addr?: string): string;
+//# sourceMappingURL=memos.d.ts.map

package/dist/core/memos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memos.d.ts","sourceRoot":"","sources":["../../src/core/memos.ts"],"names":[],"mappings":"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"}

package/dist/core/memos.js

@@ -0,0 +1,502 @@
+// memos.ts — generalized "记下来" memory database.
+//
+// Each memo carries optional 5W1H fields:
+//   what       — the core thing (REQUIRED, the only required column)
+//   who        — person / org / role involved
+//   when_at    — ISO-8601 local datetime, parseable timestamp
+//   when_text  — raw user phrase if not parseable ("明年5月" etc.)
+//   where_lat / where_lng / where_label  — geo location (full triple, partial, or none)
+//   how        — manner / process
+//   why        — reason / motivation
+//
+// Lifecycle: every row carries an optional `expires_at`. NULL = permanent;
+// otherwise a background sweep purges rows past their expiry. Used to make
+// transient state (parking spot, today's meeting room) self-clean while
+// durable info (birthdays, contacts) persists.
+//
+// Storage: ~/.im-hub/memos.db (SQLite, fail-soft via sqlite-helper).
+// Owner-scoped per (platform, user_id), same pattern as /remind, /cron.
+import { join } from 'node:path';
+import { logger as rootLogger } from './logger.js';
+import { createSqliteHelper } from './sqlite-helper.js';
+import { AGIM_HOME } from './agim-paths.js';
+const log = rootLogger.child({ component: 'memos' });
+const DB_FILE = process.env.IMHUB_MEMOS_DB || join(AGIM_HOME, 'memos.db');
+// ─── Time / timezone ───────────────────────────────────────────────────
+// All timestamps are stored in UTC+8 (Asia/Shanghai) wall-clock format,
+// matching SQLite's `datetime()` shape: "YYYY-MM-DD HH:MM:SS". This keeps
+// JS-set values (expires_at, created_at when overridden) and SQL-set
+// values (`datetime('now', '+8 hours')` in default + sweep + search)
+// lexicographically comparable. UTC+8 matches the deployment's user base
+// (CN); for other regions, the offset is overridable via env.
+const TZ_OFFSET_HOURS = Number(process.env.IMHUB_TZ_OFFSET_HOURS ?? 8);
+const TZ_OFFSET_MS = TZ_OFFSET_HOURS * 3600_000;
+const TZ_SHIFT_SQL = `'+${TZ_OFFSET_HOURS} hours'`; // for datetime('now', ...)
+/** UTC+8 wall-clock as `YYYY-MM-DD HH:MM:SS` — matches SQLite's `datetime()`
+ *  output shape so cross-source comparisons are well-defined. */
+export function nowSqliteLocal() {
+    return new Date(Date.now() + TZ_OFFSET_MS).toISOString().slice(0, 19).replace('T', ' ');
+}
+/** Convert an absolute Date (or ms) to the local-storage shape. */
+export function toSqliteLocal(d) {
+    const ms = typeof d === 'number' ? d : d.getTime();
+    return new Date(ms + TZ_OFFSET_MS).toISOString().slice(0, 19).replace('T', ' ');
+}
+/** Normalize whatever the agent passes for `when_at` into our storage shape.
+ *  Accepts: bare ISO (assumed already local), ISO with `Z` or `±HH:MM` offset,
+ *  or already-normalized "YYYY-MM-DD HH:MM:SS". Output: "YYYY-MM-DD HH:MM:SS"
+ *  in UTC+8. Falls through unchanged on parse failure rather than throwing
+ *  so an agent typo doesn't kill the save. */
+export function normalizeWhenAt(s) {
+    if (!s)
+        return null;
+    const trimmed = s.trim();
+    if (!trimmed)
+        return null;
+    // Has explicit TZ marker → parse + convert.
+    if (/Z$|[+\-]\d{2}:\d{2}$/.test(trimmed)) {
+        const ms = Date.parse(trimmed);
+        if (!Number.isFinite(ms))
+            return trimmed;
+        return toSqliteLocal(ms);
+    }
+    // Bare — assume already in our local zone. Normalize T→space, trim ms.
+    return trimmed.replace('T', ' ').slice(0, 19);
+}
+const helper = createSqliteHelper({
+    file: DB_FILE,
+    component: 'memos',
+    logger: rootLogger,
+    schema: `
+    CREATE TABLE IF NOT EXISTS memos (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      platform    TEXT    NOT NULL,
+      channel_id  TEXT    NOT NULL,
+      thread_id   TEXT    NOT NULL,
+      user_id     TEXT    NOT NULL DEFAULT '',
+
+      what        TEXT    NOT NULL,
+      who         TEXT,
+      when_at     TEXT,
+      when_text   TEXT,
+      where_lat   REAL,
+      where_lng   REAL,
+      where_label TEXT,
+      how         TEXT,
+      why         TEXT,
+      memo        TEXT,
+
+      expires_at  TEXT,
+      source      TEXT    NOT NULL DEFAULT 'agent',
+      created_at  TEXT    NOT NULL DEFAULT (datetime('now', '+8 hours')),
+      updated_at  TEXT    NOT NULL DEFAULT (datetime('now', '+8 hours'))
+    );
+    -- Idempotent migration for DBs that pre-date the memo column. SQLite
+    -- doesn't have ADD COLUMN IF NOT EXISTS; the helper's exec ignores
+    -- "duplicate column" errors via the migrate hook below.
+    CREATE INDEX IF NOT EXISTS idx_memos_user_recent
+      ON memos(platform, user_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_memos_expires
+      ON memos(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_memos_what  ON memos(what);
+    CREATE INDEX IF NOT EXISTS idx_memos_who   ON memos(who);
+  `,
+    init: (db) => {
+        // ALTER TABLE ADD COLUMN — idempotent: catch "duplicate column" and
+        // proceed. New DBs already got the column via CREATE TABLE above;
+        // old DBs (created before this column existed) get it here.
+        try {
+            db.exec("ALTER TABLE memos ADD COLUMN memo TEXT");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!/duplicate column|already exists/i.test(msg))
+                throw err;
+        }
+    },
+});
+// ─── Validation ─────────────────────────────────────────────────────────
+function assertCoords(lat, lng) {
+    if (lat == null && lng == null)
+        return; // both null is fine — no location
+    if (lat == null || lng == null)
+        throw new Error('lat and lng must both be set or both null');
+    if (!Number.isFinite(lat) || lat < -90 || lat > 90)
+        throw new Error(`invalid latitude: ${lat}`);
+    if (!Number.isFinite(lng) || lng < -180 || lng > 180)
+        throw new Error(`invalid longitude: ${lng}`);
+}
+export function createMemo(input) {
+    if (!input.what || !input.what.trim())
+        throw new Error('what is required');
+    assertCoords(input.whereLat, input.whereLng);
+    const d = helper.get();
+    if (!d)
+        throw new Error('memos DB unavailable (sqlite disabled?)');
+    const now = nowSqliteLocal(); // UTC+8 wall-clock — same shape as SQLite default
+    const whenAt = normalizeWhenAt(input.whenAt);
+    const expiresAt = normalizeWhenAt(input.expiresAt); // accept agent-supplied ISO with TZ offset
+    const stmt = d.prepare(`INSERT INTO memos
+       (platform, channel_id, thread_id, user_id,
+        what, who, when_at, when_text,
+        where_lat, where_lng, where_label,
+        how, why, memo,
+        expires_at, source,
+        created_at, updated_at)
+     VALUES (?, ?, ?, ?,  ?, ?, ?, ?,  ?, ?, ?,  ?, ?, ?,  ?, ?,  ?, ?)`);
+    const r = stmt.run(input.platform, input.channelId, input.threadId, input.userId ?? '', input.what.trim().slice(0, 200), input.who ?? null, whenAt, input.whenText ?? null, input.whereLat ?? null, input.whereLng ?? null, input.whereLabel ?? null, input.how ?? null, input.why ?? null, input.memo ?? null, expiresAt, input.source ?? 'agent', now, now);
+    log.info({
+        event: 'memos.created',
+        id: r.lastInsertRowid, platform: input.platform, userId: input.userId,
+        what: input.what, hasLocation: input.whereLat != null,
+        expiresAt, source: input.source,
+    });
+    return Number(r.lastInsertRowid);
+}
+/** Patch-style update — only fields explicitly present in the input are
+ *  written. Pass `null` to clear a field (vs `undefined` = leave alone). */
+export function updateMemo(id, input, opts = {}) {
+    if (input.what !== undefined && (!input.what || !input.what.trim())) {
+        throw new Error('what cannot be empty when updating');
+    }
+    if (input.whereLat !== undefined || input.whereLng !== undefined) {
+        // Only validate if BOTH fields are being set; partial updates of just
+        // one half are caller bugs but we don't want to assert against null
+        // when the other is being set to null too.
+        if (input.whereLat != null && input.whereLng != null) {
+            assertCoords(input.whereLat, input.whereLng);
+        }
+    }
+    const d = helper.get();
+    if (!d)
+        return false;
+    const sets = [];
+    const args = [];
+    const setIf = (col, val) => {
+        sets.push(`${col} = ?`);
+        args.push(val);
+    };
+    if (input.what !== undefined)
+        setIf('what', input.what.trim().slice(0, 200));
+    if (input.who !== undefined)
+        setIf('who', input.who);
+    if (input.whenAt !== undefined)
+        setIf('when_at', input.whenAt === null ? null : normalizeWhenAt(input.whenAt));
+    if (input.whenText !== undefined)
+        setIf('when_text', input.whenText);
+    if (input.whereLat !== undefined)
+        setIf('where_lat', input.whereLat);
+    if (input.whereLng !== undefined)
+        setIf('where_lng', input.whereLng);
+    if (input.whereLabel !== undefined)
+        setIf('where_label', input.whereLabel);
+    if (input.how !== undefined)
+        setIf('how', input.how);
+    if (input.why !== undefined)
+        setIf('why', input.why);
+    if (input.memo !== undefined)
+        setIf('memo', input.memo);
+    if (input.expiresAt !== undefined)
+        setIf('expires_at', input.expiresAt === null ? null : normalizeWhenAt(input.expiresAt));
+    if (sets.length === 0)
+        return false;
+    // Stamp updated_at with the same UTC+8 shape as create + sweep.
+    sets.push(`updated_at = ?`);
+    args.push(nowSqliteLocal());
+    const where = opts.userId ? 'id = ? AND user_id = ?' : 'id = ?';
+    const sql = `UPDATE memos SET ${sets.join(', ')} WHERE ${where}`;
+    args.push(id);
+    if (opts.userId)
+        args.push(opts.userId);
+    try {
+        const r = d.prepare(sql).run(...args);
+        log.info({ event: 'memos.updated', id, fields: sets.length - 1, changed: r.changes > 0 });
+        return r.changes > 0;
+    }
+    catch (err) {
+        log.warn({ event: 'memos.update_failed', err: err instanceof Error ? err.message : String(err) });
+        return false;
+    }
+}
+export function getMemo(id, opts = {}) {
+    return helper.safe((d) => {
+        const row = opts.userId
+            ? d.prepare('SELECT * FROM memos WHERE id = ? AND user_id = ?').get(id, opts.userId)
+            : d.prepare('SELECT * FROM memos WHERE id = ?').get(id);
+        return row ?? null;
+    }, null);
+}
+export function deleteMemo(id, opts = {}) {
+    return helper.safe((d) => {
+        const stmt = opts.userId
+            ? d.prepare('DELETE FROM memos WHERE id = ? AND user_id = ?')
+            : d.prepare('DELETE FROM memos WHERE id = ?');
+        const r = opts.userId ? stmt.run(id, opts.userId) : stmt.run(id);
+        return r.changes > 0;
+    }, false);
+}
+/**
+ * Search memos. All filters are AND-combined. Empty filter set returns the
+ * most recent memos (= same as listMemos).
+ *
+ * Sort: `created_at DESC` (newest first). Future: relevance score.
+ *
+ * Wildcard escaping: SQL LIKE `%` and `_` in the query become literal chars
+ * via `LIKE ESCAPE '\\'` — the user's question-mark or percent doesn't blow
+ * the search wide open.
+ */
+export function searchMemos(opts = {}) {
+    const limit = Math.min(Math.max(opts.limit ?? 10, 1), 50);
+    const wheres = [];
+    const args = [];
+    if (opts.userId) {
+        wheres.push('user_id = ?');
+        args.push(opts.userId);
+    }
+    if (!opts.includeExpired) {
+        // Keep rows where expires_at IS NULL (permanent) OR > now (UTC+8).
+        // Comparing UTC+8 stored shape against UTC+8 wall-clock — same TZ both
+        // sides, lexicographic compare correct around midnight crossings.
+        wheres.push(`(expires_at IS NULL OR expires_at > datetime('now', ${TZ_SHIFT_SQL}))`);
+    }
+    if (opts.hasLocation)
+        wheres.push('where_lat IS NOT NULL');
+    const escapeLike = (s) => s.replace(/[\\%_]/g, (c) => `\\${c}`);
+    if (opts.query?.trim()) {
+        const p = `%${escapeLike(opts.query.trim())}%`;
+        wheres.push(`(
+      what LIKE ? ESCAPE '\\' OR who LIKE ? ESCAPE '\\' OR
+      where_label LIKE ? ESCAPE '\\' OR how LIKE ? ESCAPE '\\' OR
+      why LIKE ? ESCAPE '\\' OR when_text LIKE ? ESCAPE '\\' OR
+      memo LIKE ? ESCAPE '\\'
+    )`);
+        for (let i = 0; i < 7; i++)
+            args.push(p);
+    }
+    if (opts.who?.trim()) {
+        wheres.push(`who LIKE ? ESCAPE '\\'`);
+        args.push(`%${escapeLike(opts.who.trim())}%`);
+    }
+    if (opts.what?.trim()) {
+        wheres.push(`what LIKE ? ESCAPE '\\'`);
+        args.push(`%${escapeLike(opts.what.trim())}%`);
+    }
+    if (opts.whenAfter) {
+        const v = normalizeWhenAt(opts.whenAfter);
+        if (v) {
+            wheres.push(`COALESCE(when_at, created_at) >= ?`);
+            args.push(v);
+        }
+    }
+    if (opts.whenBefore) {
+        const v = normalizeWhenAt(opts.whenBefore);
+        if (v) {
+            wheres.push(`COALESCE(when_at, created_at) <= ?`);
+            args.push(v);
+        }
+    }
+    const sql = `SELECT * FROM memos${wheres.length ? ' WHERE ' + wheres.join(' AND ') : ''} ORDER BY id DESC LIMIT ?`;
+    args.push(limit);
+    return helper.safe((d) => d.prepare(sql).all(...args), []);
+}
+/** Recent memos for this user. Convenience wrapper around searchMemos. */
+export function listMemos(opts = {}) {
+    return searchMemos({ userId: opts.userId, limit: opts.limit });
+}
+// ─── Expiry sweep ───────────────────────────────────────────────────────
+let sweepTimer = null;
+const SWEEP_INTERVAL_MS = 5 * 60 * 1000; // every 5 min
+export function sweepExpired() {
+    return helper.safe((d) => {
+        const r = d.prepare(`DELETE FROM memos WHERE expires_at IS NOT NULL AND expires_at <= datetime('now', ${TZ_SHIFT_SQL})`).run();
+        if (r.changes > 0)
+            log.info({ event: 'memos.sweep', removed: r.changes });
+        return r.changes;
+    }, 0);
+}
+export function startSweepTimer() {
+    if (sweepTimer)
+        return;
+    // First sweep on startup so anything stale from before this process boot
+    // gets cleaned promptly; subsequent sweeps every interval.
+    sweepExpired();
+    sweepTimer = setInterval(sweepExpired, SWEEP_INTERVAL_MS);
+    sweepTimer.unref();
+    log.info({ event: 'memos.sweep_timer_started', intervalMs: SWEEP_INTERVAL_MS });
+}
+export function stopSweepTimer() {
+    if (sweepTimer) {
+        clearInterval(sweepTimer);
+        sweepTimer = null;
+    }
+}
+export function closeMemosDb() {
+    stopSweepTimer();
+    helper.close();
+}
+// ─── Coordinate helpers (kept from old locations.ts) ────────────────────
+export function parseCoordPair(input) {
+    const trimmed = input.trim();
+    const m = trimmed.match(/^(-?\d+(?:\.\d+)?)\s*[,，\s]\s*(-?\d+(?:\.\d+)?)\b/);
+    if (!m)
+        return null;
+    const lat = Number(m[1]);
+    const lng = Number(m[2]);
+    if (!Number.isFinite(lat) || !Number.isFinite(lng))
+        return null;
+    if (lat < -90 || lat > 90 || lng < -180 || lng > 180)
+        return null;
+    return { lat, lng };
+}
+export function stripCoordPrefix(input) {
+    return input.replace(/^(-?\d+(?:\.\d+)?)\s*[,，\s]\s*(-?\d+(?:\.\d+)?)\b\s*/, '').trim();
+}
+function classifyStatus(status) {
+    if (status === 1 || status === 2 || status === 3 || status === 4)
+        return 'not_found';
+    if (status === 200 || status === 201 || status === 202)
+        return 'signature';
+    if (status >= 401 && status <= 405)
+        return 'quota';
+    if (status === 240 || status === 220 || status === 211 || status === 210)
+        return 'quota';
+    if (status === 5)
+        return 'signature';
+    return 'unknown';
+}
+export async function geocodeAddress(address) {
+    const ak = process.env.IMHUB_BAIDU_MAP_AK;
+    if (!ak) {
+        log.debug({ event: 'memos.geocode.no_key' });
+        return { ok: false, reason: 'no_key' };
+    }
+    const url = new URL('https://api.map.baidu.com/geocoding/v3/');
+    url.searchParams.set('address', address);
+    url.searchParams.set('output', 'json');
+    url.searchParams.set('ret_coordtype', 'wgs84ll');
+    url.searchParams.set('ak', ak);
+    try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 8000);
+        const res = await fetch(url.toString(), { signal: ctrl.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            return { ok: false, reason: 'http', status: res.status };
+        const data = (await res.json());
+        if (data.status === 0 && data.result?.location) {
+            const { lat, lng } = data.result.location;
+            return { ok: true, lat, lng, formattedAddress: address };
+        }
+        const reason = classifyStatus(data.status);
+        log.info({ event: 'memos.geocode.miss', status: data.status, reason, address });
+        return { ok: false, reason, status: data.status, message: data.message || data.msg };
+    }
+    catch (err) {
+        return { ok: false, reason: 'unknown', message: err instanceof Error ? err.message : String(err) };
+    }
+}
+export function isGeocodingAvailable() {
+    return !!process.env.IMHUB_BAIDU_MAP_AK;
+}
+// ─── Map URL builders (Baidu / Amap / Google) ───────────────────────────
+// Same WGS-84 → provider-coords plumbing as before. Stored coords are always
+// WGS-84; each provider URI gets the right coord-type hint.
+export function wgs84ToGcj02(lat, lng) {
+    if (outOfChina(lat, lng))
+        return { lat, lng };
+    const A = 6378245.0;
+    const EE = 0.006693421622965943;
+    const PI = Math.PI;
+    let dLat = transformLat(lng - 105.0, lat - 35.0);
+    let dLng = transformLng(lng - 105.0, lat - 35.0);
+    const radLat = (lat / 180.0) * PI;
+    let magic = Math.sin(radLat);
+    magic = 1 - EE * magic * magic;
+    const sqrtMagic = Math.sqrt(magic);
+    dLat = (dLat * 180.0) / (((A * (1 - EE)) / (magic * sqrtMagic)) * PI);
+    dLng = (dLng * 180.0) / ((A / sqrtMagic) * Math.cos(radLat) * PI);
+    return { lat: lat + dLat, lng: lng + dLng };
+}
+/**
+ * Reverse of wgs84ToGcj02. Useful when an upstream gives us GCJ-02 coords
+ * but our DB convention is WGS-84.
+ *
+ * Common case: iOS Core Location in China returns GCJ-02 by design (Apple
+ * applies the offset to comply with PRC regulations). Telegram on a Chinese
+ * iPhone forwards exactly those coords. Without this reverse, the values
+ * get re-offset when we build amap/baidu URLs → marker lands 500m–1km off.
+ *
+ * Math: GCJ→WGS doesn't have a closed-form inverse, so we use the standard
+ * Newton's-method-style refinement — compute the forward offset at the
+ * GCJ point, subtract to get a candidate WGS point, then iterate. Three
+ * passes converge to sub-meter precision for any reasonable input.
+ */
+export function gcj02ToWgs84(lat, lng) {
+    if (outOfChina(lat, lng))
+        return { lat, lng };
+    let wgsLat = lat;
+    let wgsLng = lng;
+    for (let i = 0; i < 3; i++) {
+        const forward = wgs84ToGcj02(wgsLat, wgsLng);
+        wgsLat = lat - (forward.lat - wgsLat);
+        wgsLng = lng - (forward.lng - wgsLng);
+    }
+    return { lat: wgsLat, lng: wgsLng };
+}
+function outOfChina(lat, lng) {
+    return lng < 72.004 || lng > 137.8347 || lat < 0.8293 || lat > 55.8271;
+}
+function transformLat(x, y) {
+    const PI = Math.PI;
+    let r = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+    r += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0;
+    r += ((20.0 * Math.sin(y * PI) + 40.0 * Math.sin((y / 3.0) * PI)) * 2.0) / 3.0;
+    r += ((160.0 * Math.sin((y / 12.0) * PI) + 320 * Math.sin((y * PI) / 30.0)) * 2.0) / 3.0;
+    return r;
+}
+function transformLng(x, y) {
+    const PI = Math.PI;
+    let r = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+    r += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0;
+    r += ((20.0 * Math.sin(x * PI) + 40.0 * Math.sin((x / 3.0) * PI)) * 2.0) / 3.0;
+    r += ((150.0 * Math.sin((x / 12.0) * PI) + 300.0 * Math.sin((x / 30.0) * PI)) * 2.0) / 3.0;
+    return r;
+}
+export function mapUrls(lat, lng, label = '', addr = '') {
+    return {
+        baidu: buildBaiduUrl(lat, lng, label, addr),
+        amap: buildAmapUrl(lat, lng, label),
+        google: buildGoogleUrl(lat, lng),
+    };
+}
+export function mapUrl(lat, lng, label = '', addr = '') {
+    return buildBaiduUrl(lat, lng, label, addr);
+}
+function buildBaiduUrl(lat, lng, label, addr) {
+    const url = new URL('https://api.map.baidu.com/marker');
+    url.searchParams.set('location', `${lat},${lng}`);
+    if (label)
+        url.searchParams.set('title', label);
+    if (addr)
+        url.searchParams.set('content', addr);
+    url.searchParams.set('output', 'html');
+    url.searchParams.set('coord_type', 'wgs84');
+    url.searchParams.set('src', 'imhub');
+    return url.toString();
+}
+function buildAmapUrl(lat, lng, label) {
+    const gcj = wgs84ToGcj02(lat, lng);
+    const url = new URL('https://uri.amap.com/marker');
+    url.searchParams.set('position', `${gcj.lng},${gcj.lat}`);
+    if (label)
+        url.searchParams.set('name', label);
+    url.searchParams.set('src', 'imhub');
+    url.searchParams.set('coordinate', 'gaode');
+    return url.toString();
+}
+function buildGoogleUrl(lat, lng) {
+    const url = new URL('https://www.google.com/maps');
+    url.searchParams.set('q', `${lat},${lng}`);
+    return url.toString();
+}
+//# sourceMappingURL=memos.js.map