ai-growth 1.1.0

package/dist/passport/state.js

@@ -0,0 +1,81 @@
+import { newId, ts } from '../shared/util.js';
+import { setSetting } from '../core/profile.js';
+/** 标记 Passport dirty（§8：每日计划生成、Daily Review、重要 Evidence、Goal/Stage 变化后） */
+export function flagPassportDirty(ctx, reason) {
+    const latest = ctx.db
+        .prepare('SELECT id FROM passport_snapshots ORDER BY generated_at DESC LIMIT 1')
+        .get();
+    if (latest) {
+        ctx.db.prepare('UPDATE passport_snapshots SET dirty=1 WHERE id=?').run(latest.id);
+    }
+    setSetting(ctx, 'passport_dirty_reason', reason);
+}
+export function isPassportDirty(ctx) {
+    const latest = ctx.db
+        .prepare('SELECT dirty FROM passport_snapshots ORDER BY generated_at DESC LIMIT 1')
+        .get();
+    if (latest)
+        return !!latest.dirty;
+    // 尚无快照：若已有 growth 数据（evidence / growth event / goal），视为待生成
+    const n = ctx.db
+        .prepare(`SELECT (SELECT COUNT(*) FROM evidence) + (SELECT COUNT(*) FROM growth_events)
+              + (SELECT COUNT(*) FROM goals WHERE deleted_at IS NULL) AS n`)
+        .get();
+    return n.n > 0;
+}
+export function saveSnapshot(ctx, passportJson) {
+    const id = newId();
+    ctx.db
+        .prepare('INSERT INTO passport_snapshots (id, passport, generated_at, dirty) VALUES (?,?,?,0)')
+        .run(id, passportJson, ts());
+    setSetting(ctx, 'passport_last_generated_at', ts());
+    return id;
+}
+export function latestSnapshot(ctx) {
+    const row = ctx.db
+        .prepare('SELECT * FROM passport_snapshots ORDER BY generated_at DESC LIMIT 1')
+        .get();
+    if (!row)
+        return null;
+    return { id: row.id, passport: JSON.parse(row.passport), generatedAt: row.generated_at, dirty: !!row.dirty };
+}
+// ---------- sync jobs（§29.1 失败进重试队列）----------
+export function enqueueSyncJob(ctx, payload) {
+    // 幂等：已有 PENDING 同类 job 不重复创建
+    const existing = ctx.db
+        .prepare(`SELECT id FROM sync_jobs WHERE kind='PASSPORT_SYNC' AND status='PENDING'`)
+        .get();
+    if (existing)
+        return existing.id;
+    const id = newId();
+    const now = ts();
+    ctx.db
+        .prepare(`INSERT INTO sync_jobs (id, kind, payload, status, attempts, created_at, updated_at) VALUES (?,?,?,'PENDING',0,?,?)`)
+        .run(id, 'PASSPORT_SYNC', JSON.stringify(payload), now, now);
+    return id;
+}
+export function listSyncJobs(ctx, status, limit = 20) {
+    const rows = status
+        ? ctx.db.prepare('SELECT * FROM sync_jobs WHERE status=? ORDER BY created_at DESC LIMIT ?').all(status, limit)
+        : ctx.db.prepare('SELECT * FROM sync_jobs ORDER BY created_at DESC LIMIT ?').all(limit);
+    return rows.map((r) => ({
+        id: r.id,
+        kind: r.kind,
+        status: r.status,
+        attempts: r.attempts,
+        lastError: r.last_error ?? undefined,
+        createdAt: r.created_at,
+        updatedAt: r.updated_at,
+    }));
+}
+/**
+ * 更新 sync job 状态。
+ * attempts 表示「实际发起同步的次数」，因此只在终态（DONE / FAILED）累加；
+ * RUNNING 只是过程中的状态转移，不构成一次尝试。
+ */
+export function markSyncJob(ctx, id, status, error) {
+    const countsAsAttempt = status === 'DONE' || status === 'FAILED' ? 1 : 0;
+    ctx.db
+        .prepare(`UPDATE sync_jobs SET status=?, attempts=attempts + ?, last_error=?, updated_at=? WHERE id=?`)
+        .run(status, countsAsAttempt, error ?? null, ts(), id);
+}

package/dist/passport/sync.js

@@ -0,0 +1,61 @@
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { enqueueSyncJob, listSyncJobs, markSyncJob } from './state.js';
+import { generatePassport } from './builder.js';
+export class LocalJsonPassportAdapter {
+    cfg;
+    name = 'local-json';
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    async sync(passport) {
+        mkdirSync(this.cfg.dataDir, { recursive: true });
+        const file = join(this.cfg.dataDir, this.cfg.passportFile);
+        writeFileSync(file, JSON.stringify(passport, null, 2));
+        return true;
+    }
+}
+export function createPassportAdapter(cfg) {
+    switch (cfg.passportAdapter) {
+        case 'local-json':
+        default:
+            return new LocalJsonPassportAdapter(cfg);
+    }
+}
+/** 同步（幂等）：生成 → enqueue job → 尝试同步；失败不回滚本地状态（Scenario K） */
+export async function syncPassport(ctx, adapter) {
+    const passport = generatePassport(ctx);
+    const jobId = enqueueSyncJob(ctx, { schemaVersion: passport.schemaVersion, generatedAt: passport.generatedAt });
+    try {
+        markSyncJob(ctx, jobId, 'RUNNING');
+        const okSync = await adapter.sync(passport);
+        if (okSync) {
+            markSyncJob(ctx, jobId, 'DONE');
+            return { ok: true, jobId };
+        }
+        markSyncJob(ctx, jobId, 'FAILED', 'adapter returned false');
+        return { ok: false, jobId };
+    }
+    catch (e) {
+        markSyncJob(ctx, jobId, 'FAILED', e instanceof Error ? e.message : String(e));
+        return { ok: false, jobId };
+    }
+}
+/** 重试队列中 PENDING/FAILED 的 job */
+export async function retryPendingSyncs(ctx, adapter) {
+    const jobs = listSyncJobs(ctx, 'PENDING').concat(listSyncJobs(ctx, 'FAILED'));
+    let done = 0;
+    for (const job of jobs) {
+        const passport = generatePassport(ctx);
+        try {
+            const ok = await adapter.sync(passport);
+            markSyncJob(ctx, job.id, ok ? 'DONE' : 'FAILED', ok ? undefined : 'adapter returned false');
+            if (ok)
+                done++;
+        }
+        catch (e) {
+            markSyncJob(ctx, job.id, 'FAILED', e instanceof Error ? e.message : String(e));
+        }
+    }
+    return done;
+}

package/dist/reminder/notify.js

@@ -0,0 +1,30 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** macOS 本地通知：osascript display notification */
+export class MacOsNotificationAdapter {
+    name = 'macos-local';
+    async notify(payload) {
+        const script = `display notification ${appleEscape(payload.body)} with title ${appleEscape(payload.title)}`;
+        await execFileAsync('osascript', ['-e', script], { timeout: 10_000 });
+    }
+}
+/** 静默适配器（测试 / 关闭提醒时用） */
+export class NullNotificationAdapter {
+    name = 'null';
+    async notify() { }
+}
+function appleEscape(s) {
+    // AppleScript 字符串字面量转义：反斜杠和双引号
+    const escaped = s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return `"${escaped}"`;
+}
+export function createNotificationAdapter(kind = 'macos-local') {
+    switch (kind) {
+        case 'macos-local':
+            return new MacOsNotificationAdapter();
+        case 'none':
+        default:
+            return new NullNotificationAdapter();
+    }
+}

package/dist/reminder/scheduler.js

@@ -0,0 +1,87 @@
+import { loadConfig } from '../shared/config.js';
+import { openDb } from '../db/client.js';
+import { makeCtx } from '../mcp/ctx.js';
+import { runDailyRollover } from '../core/rollover.js';
+import { deactivateExpiredLifeContexts } from '../core/lifeContext.js';
+import { listDueReminders, markReminderSent } from './service.js';
+import { createNotificationAdapter } from './notify.js';
+import { retryPendingSyncs, createPassportAdapter } from '../passport/sync.js';
+import { getAction } from '../core/actions.js';
+import { nowIso } from '../shared/time.js';
+const CHECK_INTERVAL_MS = 30_000; // 30s：提醒精度 & rollover 检测
+const SYNC_RETRY_INTERVAL_MS = 10 * 60_000;
+/**
+ * 常驻 Scheduler（§12）：
+ * - 每 tick：rollover（幂等）→ 到期提醒触发（幂等）→ 过期 LifeContext 清理
+ * - 定期重试 Passport 同步
+ * - 崩溃/重启后自动恢复（所有状态在 DB，进程无状态）
+ */
+export class Scheduler {
+    timer;
+    syncTimer;
+    running = false;
+    db;
+    cfg;
+    notifier;
+    constructor(db, cfg, notifier) {
+        this.cfg = cfg ?? loadConfig();
+        this.db = db ?? openDb(this.cfg.dataDir);
+        this.notifier = notifier ?? createNotificationAdapter('macos-local');
+    }
+    start() {
+        this.tick(); // 启动立即跑一次（覆盖开机错过的时间）
+        this.timer = setInterval(() => this.tick(), CHECK_INTERVAL_MS);
+        this.syncTimer = setInterval(() => this.syncTick(), SYNC_RETRY_INTERVAL_MS);
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.syncTimer)
+            clearInterval(this.syncTimer);
+    }
+    /** 单次 tick：可独立调用（测试 / API 触发） */
+    async tick() {
+        if (this.running)
+            return { rolloverRan: false, remindersFired: 0, lifeContextsExpired: 0 }; // 防重入
+        this.running = true;
+        try {
+            const ctx = makeCtx(this.db, this.cfg, 'daemon');
+            const rollover = runDailyRollover(ctx);
+            const lifeExpired = deactivateExpiredLifeContexts(ctx);
+            const fired = await this.fireDueReminders(ctx);
+            return { rolloverRan: !rollover.alreadyRan, remindersFired: fired, lifeContextsExpired: lifeExpired };
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async fireDueReminders(ctx) {
+        const due = listDueReminders(ctx, nowIso());
+        let fired = 0;
+        for (const rem of due) {
+            // 幂等标记先做；通知失败不回滚状态（下次不会重复发）
+            markReminderSent(ctx, rem.id);
+            const action = getAction(ctx, rem.actionId);
+            try {
+                await this.notifier.notify({
+                    title: action ? `AI Growth: ${action.title}` : 'AI Growth 提醒',
+                    body: action?.completionCriteria ?? '该做今天的任务了',
+                });
+                fired++;
+            }
+            catch (e) {
+                process.stderr.write(`[ai-growth] notify failed: ${e instanceof Error ? e.message : e}\n`);
+            }
+        }
+        return fired;
+    }
+    async syncTick() {
+        const ctx = makeCtx(this.db, this.cfg, 'daemon');
+        try {
+            await retryPendingSyncs(ctx, createPassportAdapter(this.cfg));
+        }
+        catch (e) {
+            process.stderr.write(`[ai-growth] passport sync retry failed: ${e instanceof Error ? e.message : e}\n`);
+        }
+    }
+}

package/dist/reminder/service.js

@@ -0,0 +1,102 @@
+import { writeAudit } from '../core/context.js';
+import { newId, ts } from '../shared/util.js';
+import { DomainError, ErrorCodes } from '../shared/result.js';
+import { todayIn } from '../core/profile.js';
+function rowToReminder(r) {
+    return {
+        id: r.id, actionId: r.action_id, scheduledAt: r.scheduled_at,
+        status: r.status, channel: r.channel,
+        firedAt: r.fired_at ?? undefined, cancelledAt: r.cancelled_at ?? undefined,
+    };
+}
+/**
+ * 提醒创建（V1.1 §24）：
+ * - Reminder 与 Action 生命周期绑定
+ * - 默认每个 DAILY action 最多 1 个未触发提醒
+ */
+export function createReminder(ctx, input) {
+    const action = ctx.db.prepare('SELECT id, date_key, status FROM actions WHERE id=?').get(input.actionId);
+    if (!action)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Action not found: ${input.actionId}`);
+    if (['COMPLETED', 'SKIPPED', 'CANCELLED', 'EXPIRED'].includes(action.status)) {
+        throw new DomainError(ErrorCodes.INVALID_STATE, `Cannot create reminder for action in status ${action.status}`);
+    }
+    const kind = ctx.db.prepare('SELECT kind FROM actions WHERE id=?').get(input.actionId);
+    if (kind.kind === 'DAILY' && !input.allowMultiple) {
+        const existing = ctx.db
+            .prepare(`SELECT COUNT(*) AS n FROM reminders WHERE action_id=? AND status='SCHEDULED'`)
+            .get(input.actionId);
+        if (existing.n >= 1) {
+            throw new DomainError(ErrorCodes.INVALID_STATE, 'Daily action already has 1 scheduled reminder (V1.1 §24 max rule). Pass allowMultiple or update the existing one.');
+        }
+    }
+    const id = newId();
+    const now = ts();
+    ctx.db
+        .prepare(`INSERT INTO reminders (id, action_id, scheduled_at, status, channel, created_at, updated_at)
+       VALUES (?,?,?,'SCHEDULED',?,?,?)`)
+        .run(id, input.actionId, input.scheduledAt, input.channel ?? 'LOCAL_NOTIFICATION', now, now);
+    const rem = getReminder(ctx, id);
+    writeAudit(ctx, { entityType: 'reminder', entityId: id, after: rem, reason: 'create reminder' });
+    return rem;
+}
+export function getReminder(ctx, id) {
+    const row = ctx.db.prepare('SELECT * FROM reminders WHERE id=?').get(id);
+    return row ? rowToReminder(row) : null;
+}
+export function updateReminder(ctx, id, scheduledAt) {
+    const before = getReminder(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Reminder not found: ${id}`);
+    if (before.status !== 'SCHEDULED')
+        throw new DomainError(ErrorCodes.INVALID_STATE, `Cannot update reminder in status ${before.status}`);
+    ctx.db.prepare('UPDATE reminders SET scheduled_at=?, updated_at=? WHERE id=?').run(scheduledAt, ts(), id);
+    return getReminder(ctx, id);
+}
+export function cancelReminder(ctx, id, reason = 'cancelled') {
+    const before = getReminder(ctx, id);
+    if (!before)
+        throw new DomainError(ErrorCodes.NOT_FOUND, `Reminder not found: ${id}`);
+    if (before.status !== 'SCHEDULED')
+        return before; // 幂等
+    ctx.db
+        .prepare(`UPDATE reminders SET status='CANCELLED', cancelled_at=?, updated_at=? WHERE id=?`)
+        .run(ts(), ts(), id);
+    const after = getReminder(ctx, id);
+    writeAudit(ctx, { entityType: 'reminder', entityId: id, before, after, reason });
+    return after;
+}
+/** 取消某 action 全部未触发提醒（幂等） */
+export function cancelRemindersByAction(ctx, actionId, reason) {
+    const now = ts();
+    const res = ctx.db
+        .prepare(`UPDATE reminders SET status='CANCELLED', cancelled_at=?, updated_at=? WHERE action_id=? AND status='SCHEDULED'`)
+        .run(now, now, actionId);
+    if (res.changes > 0) {
+        writeAudit(ctx, { entityType: 'reminder', entityId: actionId, after: { cancelled: res.changes }, reason });
+    }
+    return res.changes;
+}
+export function listRemindersForDate(ctx, dateKey) {
+    const key = dateKey ?? todayIn(ctx);
+    // dateKey 是自然日；scheduled_at 是 ISO。取 [key 00:00, key+1 00:00) 区间在 tz 下的提醒
+    const rows = ctx.db
+        .prepare(`SELECT r.* FROM reminders r JOIN actions a ON a.id = r.action_id
+       WHERE a.date_key = ? AND r.status != 'CANCELLED' ORDER BY r.scheduled_at`)
+        .all(key);
+    return rows.map(rowToReminder);
+}
+/** 到期待触发提醒（Scheduler 轮询用，幂等：SCHEDULED 且 scheduled_at <= now） */
+export function listDueReminders(ctx, nowIsoStr = ts()) {
+    const rows = ctx.db
+        .prepare(`SELECT * FROM reminders WHERE status='SCHEDULED' AND scheduled_at <= ?
+       ORDER BY scheduled_at LIMIT 50`)
+        .all(nowIsoStr);
+    return rows.map(rowToReminder);
+}
+export function markReminderSent(ctx, id, firedAt) {
+    ctx.db
+        .prepare(`UPDATE reminders SET status='SENT', fired_at=?, updated_at=? WHERE id=? AND status='SCHEDULED'`)
+        .run(firedAt ?? ts(), ts(), id);
+    return getReminder(ctx, id);
+}

package/dist/shared/config.js

@@ -0,0 +1,50 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function loadEnvFile() {
+    // 依次查找：项目根 .env（开发）、数据目录 config.env
+    const candidates = [join(process.cwd(), '.env'), join(homedir(), '.ai-growth', 'config.env')];
+    for (const p of candidates) {
+        if (!existsSync(p))
+            continue;
+        try {
+            for (const line of readFileSync(p, 'utf8').split('\n')) {
+                const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+                if (m && process.env[m[1]] === undefined) {
+                    process.env[m[1]] = m[2].replace(/^["']|["']$/g, '');
+                }
+            }
+        }
+        catch {
+            /* ignore malformed env files */
+        }
+    }
+}
+function defaultTz() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone || 'Asia/Shanghai';
+    }
+    catch {
+        return 'Asia/Shanghai';
+    }
+}
+export function loadConfig(overrides = {}) {
+    loadEnvFile();
+    const dataDir = (overrides.dataDir ??
+        process.env.AI_GROWTH_DATA_DIR ??
+        join(homedir(), '.ai-growth')).replace(/^~(?=\/)/, homedir());
+    return {
+        dataDir,
+        timezone: overrides.timezone ?? process.env.AI_GROWTH_TZ ?? defaultTz(),
+        logLevel: process.env.AI_GROWTH_LOG_LEVEL ?? 'info',
+        apiPort: Number(process.env.AI_GROWTH_API_PORT ?? 4580),
+        passportAdapter: process.env.AI_GROWTH_PASSPORT_ADAPTER ?? 'local-json',
+        passportFile: process.env.AI_GROWTH_PASSPORT_FILE ?? 'passport.json',
+        // ⚠ 默认值必须是空串，不能是 '0'：这个字段用来判断"用户有没有显式设置过环境变量"。
+        //   默认值若为 '0'，它就永远非空，于是 isDeviceLanEnabled 永远走环境变量分支，
+        //   数据库里持久化过的那个开关再也读不到（"开启局域网"就存不住了）。
+        //   语义：'' = 没设，交给设置表；'0'/'1' = 显式指定，环境变量优先。
+        deviceLan: process.env.AI_GROWTH_DEVICE_LAN ?? '',
+        ...overrides,
+    };
+}

package/dist/shared/result.js

@@ -0,0 +1,27 @@
+export const ErrorCodes = {
+    ONBOARDING_REQUIRED: 'ONBOARDING_REQUIRED',
+    CONFIRMATION_REQUIRED: 'CONFIRMATION_REQUIRED',
+    REPLAN_REQUIRED: 'REPLAN_REQUIRED',
+    INVALID_STATE: 'INVALID_STATE',
+    NOT_FOUND: 'NOT_FOUND',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    ALREADY_EXISTS: 'ALREADY_EXISTS',
+    INTERNAL: 'INTERNAL',
+};
+export function ok(data, suggestedNextOperation) {
+    return { ok: true, data, ...(suggestedNextOperation ? { suggestedNextOperation } : {}) };
+}
+export function err(code, message, retryable = false) {
+    return { ok: false, error: { code, message, retryable } };
+}
+/** Core 层业务错误：携带错误码，可被 MCP/API 层转换为 ToolResult */
+export class DomainError extends Error {
+    code;
+    retryable;
+    constructor(code, message, retryable = false) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'DomainError';
+    }
+}

package/dist/shared/time.js

@@ -0,0 +1,67 @@
+/**
+ * 时间处理。核心规则：
+ * - DB 存 ISO timestamp（UTC）。
+ * - "哪一天" 的判断必须基于配置的本地 timezone，不能按 UTC 截断。
+ */
+const dateKeyFormatterCache = new Map();
+function fmt(tz) {
+    let f = dateKeyFormatterCache.get(tz);
+    if (!f) {
+        // en-CA gives YYYY-MM-DD shape
+        f = new Intl.DateTimeFormat('en-CA', { timeZone: tz, year: 'numeric', month: '2-digit', day: '2-digit' });
+        dateKeyFormatterCache.set(tz, f);
+    }
+    return f;
+}
+/** 本地自然日 key：YYYY-MM-DD（按 tz） */
+export function localDateKey(date = new Date(), tz = 'Asia/Shanghai') {
+    return fmt(tz).format(date);
+}
+/** 当前 ISO timestamp */
+export function nowIso() {
+    return new Date().toISOString();
+}
+/** 该时刻在 tz 下的偏移量（毫秒）。东八区为 +8h，纽约夏令时为 -4h */
+function tzOffsetMs(at, tz) {
+    const dtf = new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        hour12: false,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit',
+    });
+    const parts = dtf.formatToParts(at);
+    const get = (t) => Number(parts.find((p) => p.type === t)?.value ?? '0');
+    // 把"该 tz 的墙上时间"当成 UTC 读出来，与实际 UTC 的差就是 offset
+    const asIfUtc = Date.UTC(get('year'), get('month') - 1, get('day'), get('hour') % 24, get('minute'), get('second'));
+    return asIfUtc - at.getTime();
+}
+/**
+ * 把 "YYYY-MM-DD" + tz 解析为该自然日起始时刻的 UTC Date。
+ * 用 offset 反解，而不是"迭代加天"——后者对负偏移时区（美洲）会直接失败。
+ * 二次校正用于跨越 DST 边界的情况。
+ */
+export function startOfDateKey(dateKey, tz) {
+    const guess = new Date(`${dateKey}T00:00:00Z`);
+    const offset = tzOffsetMs(guess, tz);
+    const candidate = new Date(guess.getTime() - offset);
+    // DST 边界：候选时刻的 offset 可能与 guess 时刻不同，需要用正确的 offset 再解一次
+    const candidateOffset = tzOffsetMs(candidate, tz);
+    if (candidateOffset !== offset) {
+        return new Date(guess.getTime() - candidateOffset);
+    }
+    return candidate;
+}
+/** 给定 ISO timestamp 在指定 tz 是否早于某自然日（严格） */
+export function isBeforeDateKey(iso, dateKey, tz) {
+    return localDateKey(new Date(iso), tz) < dateKey;
+}
+/** 加/减自然日，返回新 key */
+export function addDays(dateKey, days) {
+    const d = new Date(`${dateKey}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d.toISOString().slice(0, 10);
+}
+/** 今天在 tz 下的 key */
+export function todayKey(tz) {
+    return localDateKey(new Date(), tz);
+}

package/dist/shared/util.js

@@ -0,0 +1,21 @@
+import { randomUUID } from 'node:crypto';
+import { nowIso } from '../shared/time.js';
+export function newId() {
+    return randomUUID();
+}
+export function ts() {
+    return nowIso();
+}
+export function j(v) {
+    return JSON.stringify(v);
+}
+export function pj(s, fallback) {
+    if (!s)
+        return fallback;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return fallback;
+    }
+}