codeksei 0.1.0

package/src/app/review-cli.js

@@ -0,0 +1,134 @@
+const { buildReview, writeReview } = require("../core/review");
+
+async function runReviewCommand(config, kind, args = process.argv.slice(4)) {
+  const options = parseReviewArgs(args, kind);
+  if (options.help) {
+    printReviewHelp(kind);
+    return;
+  }
+  if (options.stdout) {
+    const review = await buildReview(config, kind, options);
+    process.stdout.write(review.draft.periodTitle + "\n");
+    process.stdout.write(review.draft.windowFacts.map((line) => `- ${line}`).join("\n") + "\n");
+    return;
+  }
+  const result = await writeReview(config, kind, options);
+  const action = result.changed ? "updated" : "noop";
+  const semantic = result.semanticUsed ? " semantic=hybrid" : "";
+  console.log(`review ${action}: ${result.filePath} [${kind}:${result.periodLabel}] diaries=${result.diaryCount}${semantic}`);
+}
+
+function parseReviewArgs(args, kind) {
+  const options = {
+    help: false,
+    stdout: false,
+    deterministic: false,
+    date: "",
+    week: "",
+    month: "",
+    model: "",
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || "").trim();
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--stdout") {
+      options.stdout = true;
+      continue;
+    }
+    if (arg === "--deterministic") {
+      options.deterministic = true;
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      throw new Error(`未知参数: ${arg}`);
+    }
+    const value = String(args[index + 1] || "");
+    if (!value || value.startsWith("--")) {
+      throw new Error(`参数缺少值: ${arg}`);
+    }
+    if (arg === "--date") {
+      options.date = value;
+    } else if (arg === "--week") {
+      options.week = value;
+    } else if (arg === "--month") {
+      options.month = value;
+    } else if (arg === "--model") {
+      options.model = value;
+    } else {
+      throw new Error(`未知参数: ${arg}`);
+    }
+    index += 1;
+  }
+
+  if (kind === "weekly" && options.month) {
+    throw new Error("review:weekly 不支持 --month");
+  }
+  if (kind === "monthly" && options.week) {
+    throw new Error("review:monthly 不支持 --week");
+  }
+  if (kind === "nightly" && (options.week || options.month)) {
+    throw new Error("review:nightly 只支持 --date");
+  }
+
+  return options;
+}
+
+function printReviewHelp(kind) {
+  const nightly = [
+    "用法: npm run review:nightly -- [--date YYYY-MM-DD] [--stdout] [--deterministic] [--model <id>]",
+    "",
+    "说明：",
+    "  从当前 diary 真相源生成一份 Codeksei 睡前收口。",
+    "  默认按 Asia/Shanghai 的当前日期推断今天，并给周/月复盘提供更轻的日级原料。",
+    "  默认走 hybrid：脚本保骨架，Codex 负责结构化语义提炼；失败时自动回退。",
+    "",
+    "示例：",
+    "  npm run review:nightly",
+    "  npm run review:nightly -- --date 2026-04-10",
+  ].join("\n");
+
+  const weekly = [
+    "用法: npm run review:weekly -- [--week YYYY-Www] [--date YYYY-MM-DD] [--stdout] [--deterministic] [--model <id>]",
+    "",
+    "说明：",
+    "  从当前 diary 真相源生成一份 Codeksei 生活助理周复盘。",
+    "  默认按 Asia/Shanghai 的当前日期推断本周（周一到周日）。",
+    "  默认走 hybrid：脚本保骨架，Codex 负责结构化语义提炼；失败时自动回退。",
+    "",
+    "示例：",
+    "  npm run review:weekly",
+    "  npm run review:weekly -- --week 2026-W15",
+    "  npm run review:weekly -- --date 2026-04-11",
+  ].join("\n");
+
+  const monthly = [
+    "用法: npm run review:monthly -- [--month YYYY-MM] [--date YYYY-MM-DD] [--stdout] [--deterministic] [--model <id>]",
+    "",
+    "说明：",
+    "  从当前 diary 真相源生成一份 Codeksei 生活助理月复盘。",
+    "  默认按 Asia/Shanghai 的当前日期推断本月。",
+    "  默认走 hybrid：脚本保骨架，Codex 负责结构化语义提炼；失败时自动回退。",
+    "",
+    "示例：",
+    "  npm run review:monthly",
+    "  npm run review:monthly -- --month 2026-04",
+    "  npm run review:monthly -- --date 2026-04-11",
+  ].join("\n");
+
+  if (kind === "nightly") {
+    console.log(nightly);
+    return;
+  }
+  console.log(kind === "weekly" ? weekly : monthly);
+}
+
+module.exports = {
+  parseReviewArgs,
+  runReviewCommand,
+};

package/src/app/system-checkin-poller.js

@@ -0,0 +1,100 @@
+const crypto = require("crypto");
+
+const { resolveSelectedAccount } = require("../adapters/channel/weixin/account-store");
+const { SessionStore } = require("../adapters/runtime/codex/session-store");
+const { PACKAGE_NAME, readPrefixedEnv } = require("../core/branding");
+const { resolvePreferredSenderId, resolvePreferredWorkspaceRoot } = require("../core/default-targets");
+const { SystemMessageQueueStore } = require("../core/system-message-queue-store");
+
+const DEFAULT_MIN_INTERVAL_MS = 3 * 60_000;
+const DEFAULT_MAX_INTERVAL_MS = 60 * 60_000;
+const INTERNAL_CHECKIN_TRIGGER_TEMPLATE = "Decide whether to reach out to %USER% now. You may stay silent, send one short WeChat message, update diary/timeline, or take another useful action. If no user-visible message should be sent, output exactly SILENT. If you do send a message, output only the message text.";
+
+async function runSystemCheckinPoller(config) {
+  const account = resolveSelectedAccount(config);
+  const queue = new SystemMessageQueueStore({ filePath: config.systemMessageQueueFile });
+  const sessionStore = new SessionStore({ filePath: config.sessionsFile });
+  const target = resolvePollerTarget({ config, account, sessionStore });
+  const minIntervalMs = readIntervalMs(readPrefixedEnv(process.env, "CHECKIN_MIN_INTERVAL_MS"), DEFAULT_MIN_INTERVAL_MS);
+  const maxIntervalMs = Math.max(
+    minIntervalMs,
+    readIntervalMs(readPrefixedEnv(process.env, "CHECKIN_MAX_INTERVAL_MS"), DEFAULT_MAX_INTERVAL_MS)
+  );
+
+  console.log(`[${PACKAGE_NAME}] checkin poller ready user=${target.senderId} workspace=${target.workspaceRoot}`);
+  console.log(`[${PACKAGE_NAME}] checkin interval range ${Math.round(minIntervalMs / 60000)}m-${Math.round(maxIntervalMs / 60000)}m`);
+
+  while (true) {
+    const delayMs = pickRandomDelayMs(minIntervalMs, maxIntervalMs);
+    const wakeAt = new Date(Date.now() + delayMs).toISOString();
+    console.log(`[${PACKAGE_NAME}] next checkin in ${Math.round(delayMs / 60000)}m at ${wakeAt}`);
+    await sleep(delayMs);
+
+    if (queue.hasPendingForAccount(account.accountId)) {
+      console.log(`[${PACKAGE_NAME}] checkin skipped: pending system message still in queue`);
+      continue;
+    }
+
+    const queued = queue.enqueue({
+      id: crypto.randomUUID(),
+      accountId: account.accountId,
+      senderId: target.senderId,
+      workspaceRoot: target.workspaceRoot,
+      text: buildCheckinTrigger(config),
+      createdAt: new Date().toISOString(),
+    });
+    console.log(`[${PACKAGE_NAME}] checkin queued id=${queued.id}`);
+  }
+}
+
+function resolvePollerTarget({ config, account, sessionStore }) {
+  const senderId = resolvePreferredSenderId({
+    config,
+    accountId: account.accountId,
+    explicitUser: readPrefixedEnv(process.env, "CHECKIN_USER_ID") || "",
+    sessionStore,
+  });
+  const workspaceRoot = resolvePreferredWorkspaceRoot({
+    config,
+    accountId: account.accountId,
+    senderId,
+    explicitWorkspace: readPrefixedEnv(process.env, "CHECKIN_WORKSPACE") || "",
+    sessionStore,
+  });
+
+  if (!senderId) {
+    throw new Error("无法确定 checkin poller 的微信用户，先配置 CODEKSEI_CHECKIN_USER_ID（或旧的 CYBERBOSS_CHECKIN_USER_ID）或让唯一活跃用户先和 bot 聊过一次");
+  }
+  if (!workspaceRoot) {
+    throw new Error("无法确定 checkin poller 的 workspace，先设置 CODEKSEI_WORKSPACE_ROOT（或旧的 CYBERBOSS_WORKSPACE_ROOT）");
+  }
+
+  return { senderId, workspaceRoot };
+}
+
+function readIntervalMs(rawValue, fallback) {
+  const parsed = Number.parseInt(String(rawValue || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function pickRandomDelayMs(minIntervalMs, maxIntervalMs) {
+  if (maxIntervalMs <= minIntervalMs) {
+    return minIntervalMs;
+  }
+  return minIntervalMs + Math.floor(Math.random() * (maxIntervalMs - minIntervalMs + 1));
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function buildCheckinTrigger(config) {
+  const userName = normalizeText(config?.userName) || "用户";
+  return INTERNAL_CHECKIN_TRIGGER_TEMPLATE.replace("%USER%", userName);
+}
+
+module.exports = { runSystemCheckinPoller };

package/src/app/system-send-cli.js

@@ -0,0 +1,129 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const { resolveSelectedAccount } = require("../adapters/channel/weixin/account-store");
+const { loadPersistedContextTokens } = require("../adapters/channel/weixin/context-token-store");
+const { SessionStore } = require("../adapters/runtime/codex/session-store");
+const { resolvePreferredSenderId, resolvePreferredWorkspaceRoot } = require("../core/default-targets");
+const { SystemMessageQueueStore } = require("../core/system-message-queue-store");
+
+async function runSystemSendCommand(config) {
+  const options = parseSystemSendArgs(process.argv.slice(4));
+  if (options.help) {
+    printSystemSendHelp();
+    return;
+  }
+
+  const account = resolveSelectedAccount(config);
+  const sessionStore = new SessionStore({ filePath: config.sessionsFile });
+  const senderId = resolvePreferredSenderId({
+    config,
+    accountId: account.accountId,
+    explicitUser: options.user,
+    sessionStore,
+  });
+  const text = options.text;
+  const workspaceRoot = resolvePreferredWorkspaceRoot({
+    config,
+    accountId: account.accountId,
+    senderId,
+    explicitWorkspace: options.workspace,
+    sessionStore,
+  });
+  if (!senderId || !text || !workspaceRoot) {
+    printSystemSendHelp();
+    throw new Error("system send 缺少必要参数");
+  }
+  if (!path.isAbsolute(workspaceRoot)) {
+    throw new Error(`workspace 必须是绝对路径: ${workspaceRoot}`);
+  }
+
+  let workspaceStats = null;
+  try {
+    workspaceStats = fs.statSync(workspaceRoot);
+  } catch {
+    throw new Error(`workspace 不存在: ${workspaceRoot}`);
+  }
+  if (!workspaceStats.isDirectory()) {
+    throw new Error(`workspace 不是目录: ${workspaceRoot}`);
+  }
+
+  const contextTokens = loadPersistedContextTokens(config, account.accountId);
+  if (!contextTokens[senderId]) {
+    throw new Error(`找不到用户 ${senderId} 的 context token，先让这个用户和 bot 聊过一次`);
+  }
+  const queue = new SystemMessageQueueStore({ filePath: config.systemMessageQueueFile });
+  const queued = queue.enqueue({
+    id: crypto.randomUUID(),
+    accountId: account.accountId,
+    senderId,
+    workspaceRoot,
+    text,
+    createdAt: new Date().toISOString(),
+  });
+
+  console.log(`system message queued: ${queued.id}`);
+  console.log(`user: ${queued.senderId}`);
+  console.log(`workspace: ${queued.workspaceRoot}`);
+}
+
+function parseSystemSendArgs(args) {
+  const options = {
+    help: false,
+    user: "",
+    text: "",
+    workspace: "",
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = String(args[index] || "").trim();
+    if (!token) {
+      continue;
+    }
+
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      continue;
+    }
+
+    if (!token.startsWith("--")) {
+      throw new Error(`未知参数: ${token}`);
+    }
+
+    const key = token.slice(2);
+    const value = String(args[index + 1] || "");
+    if (!value || value.startsWith("--")) {
+      throw new Error(`参数缺少值: ${token}`);
+    }
+
+    if (key === "user") {
+      options.user = value.trim();
+    } else if (key === "text") {
+      options.text = value.trim();
+    } else if (key === "workspace") {
+      options.workspace = value.trim();
+    } else {
+      throw new Error(`未知参数: ${token}`);
+    }
+
+    index += 1;
+  }
+
+  return options;
+}
+
+function printSystemSendHelp() {
+  console.log(`
+用法: npm run system:send -- --text "<message>" [--user <wechat_user_id>] [--workspace /绝对路径]
+
+示例:
+  npm run system:send -- --text "提醒她今天早点睡" --workspace "$(pwd)"
+`);
+}
+
+function normalizeWorkspacePath(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = { runSystemSendCommand };

package/src/app/timeline-event-cli.js

@@ -0,0 +1,273 @@
+const crypto = require("crypto");
+
+const LOCAL_TIMEZONE_OFFSET = "+08:00";
+
+async function runTimelineEventCommand(timelineIntegration, args = process.argv.slice(4)) {
+  const options = parseTimelineEventArgs(args);
+  if (options.help) {
+    printTimelineEventHelp();
+    return;
+  }
+
+  const note = await resolveNote(options);
+  const writeArgs = buildTimelineEventWriteArgs(options, note);
+  await timelineIntegration.runSubcommand("write", writeArgs);
+}
+
+function parseTimelineEventArgs(args) {
+  const options = {
+    help: false,
+    date: "",
+    start: "",
+    end: "",
+    title: "",
+    note: "",
+    categoryId: "",
+    subcategoryId: "",
+    eventNodeId: "",
+    mode: "merge",
+    eventId: "",
+    finalize: false,
+    useStdin: false,
+    tags: [],
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = String(args[index] || "").trim();
+    if (!token) {
+      continue;
+    }
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (token === "--stdin") {
+      options.useStdin = true;
+      continue;
+    }
+    if (token === "--finalize") {
+      options.finalize = true;
+      continue;
+    }
+
+    const value = String(args[index + 1] || "").trim();
+    if (!value || value.startsWith("--")) {
+      throw new Error(`参数缺少值: ${token}`);
+    }
+
+    switch (token) {
+      case "--date":
+        options.date = value;
+        break;
+      case "--start":
+        options.start = value;
+        break;
+      case "--end":
+        options.end = value;
+        break;
+      case "--title":
+        options.title = value;
+        break;
+      case "--note":
+        options.note = value;
+        break;
+      case "--category":
+        options.categoryId = value;
+        break;
+      case "--subcategory":
+        options.subcategoryId = value;
+        break;
+      case "--event-node":
+        options.eventNodeId = value;
+        break;
+      case "--mode":
+        options.mode = value;
+        break;
+      case "--id":
+        options.eventId = value;
+        break;
+      case "--tag":
+        options.tags.push(value);
+        break;
+      default:
+        throw new Error(`未知参数: ${token}`);
+    }
+    index += 1;
+  }
+
+  return options;
+}
+
+async function resolveNote(options) {
+  const inline = normalizeText(options.note);
+  if (inline) {
+    return inline;
+  }
+  if (!options.useStdin && process.stdin.isTTY) {
+    return "";
+  }
+  return normalizeText(await readStdin());
+}
+
+function buildTimelineEventWriteArgs(options, note = "") {
+  const date = normalizeDate(options.date);
+  if (!date) {
+    throw new Error("缺少有效日期，使用 --date YYYY-MM-DD");
+  }
+
+  const title = normalizeText(options.title);
+  if (!title) {
+    throw new Error("缺少标题，使用 --title \"事件标题\"");
+  }
+
+  const mode = normalizeText(options.mode) || "merge";
+  if (!["merge", "replace"].includes(mode)) {
+    throw new Error("不支持的写入模式，只能用 --mode merge|replace");
+  }
+
+  if (!normalizeText(options.eventNodeId) && !normalizeText(options.subcategoryId)) {
+    throw new Error("缺少分类信息，至少传 --event-node 或 --subcategory");
+  }
+
+  const startAt = normalizeTimelineEventTimestamp(date, options.start, "--start");
+  const endAt = normalizeTimelineEventTimestamp(date, options.end, "--end");
+  validateEventRange({ date, startAt, endAt });
+
+  const event = {
+    id: normalizeText(options.eventId) || `evt_${crypto.randomUUID()}`,
+    startAt,
+    endAt,
+    title,
+  };
+  if (note) {
+    event.note = note;
+  }
+  if (normalizeText(options.categoryId)) {
+    event.categoryId = normalizeText(options.categoryId);
+  }
+  if (normalizeText(options.subcategoryId)) {
+    event.subcategoryId = normalizeText(options.subcategoryId);
+  }
+  if (normalizeText(options.eventNodeId)) {
+    event.eventNodeId = normalizeText(options.eventNodeId);
+  }
+  if (Array.isArray(options.tags) && options.tags.length) {
+    event.tags = options.tags.map((tag) => normalizeText(tag)).filter(Boolean);
+  }
+
+  const payload = {
+    date,
+    events: [event],
+  };
+
+  const args = [
+    "--date",
+    date,
+    "--mode",
+    mode,
+    "--json",
+    JSON.stringify(payload),
+  ];
+  if (options.finalize) {
+    args.push("--finalize");
+  }
+  return args;
+}
+
+function normalizeDate(value) {
+  const normalized = normalizeText(value);
+  return /^\d{4}-\d{2}-\d{2}$/.test(normalized) ? normalized : "";
+}
+
+function normalizeTimelineEventTimestamp(date, value, flagName) {
+  const normalized = normalizeText(value);
+  if (!normalized) {
+    throw new Error(`缺少时间，使用 ${flagName} HH:mm 或完整时间戳`);
+  }
+
+  if (/^\d{2}:\d{2}$/.test(normalized)) {
+    return `${date}T${normalized}:00${LOCAL_TIMEZONE_OFFSET}`;
+  }
+
+  if (/^\d{2}:\d{2}:\d{2}$/.test(normalized)) {
+    return `${date}T${normalized}${LOCAL_TIMEZONE_OFFSET}`;
+  }
+
+  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2})?$/.test(normalized)) {
+    return `${normalized.replace(" ", "T")}${LOCAL_TIMEZONE_OFFSET}`;
+  }
+
+  if (/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?([zZ]|[+-]\d{2}:\d{2})$/.test(normalized)) {
+    return normalized.replace(" ", "T");
+  }
+
+  throw new Error(`不支持的时间格式: ${flagName}=${normalized}`);
+}
+
+function validateEventRange({ date, startAt, endAt }) {
+  if (!startAt.startsWith(`${date}T`) || !endAt.startsWith(`${date}T`)) {
+    throw new Error("timeline:event 要求 start/end 都落在 --date 对应这一天内");
+  }
+
+  const startMs = Date.parse(startAt);
+  const endMs = Date.parse(endAt);
+  if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) {
+    throw new Error("无法解析 start/end 时间");
+  }
+  if (startMs >= endMs) {
+    throw new Error("--end 必须晚于 --start，且 timeline:event 不支持跨天事件");
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      buffer += chunk;
+    });
+    process.stdin.on("end", () => resolve(buffer));
+    process.stdin.on("error", reject);
+  });
+}
+
+function normalizeText(value) {
+  return String(value || "").replace(/\r\n/g, "\n").trim();
+}
+
+function printTimelineEventHelp() {
+  console.log(`
+用法: npm run timeline:event -- --date YYYY-MM-DD --start HH:mm --end HH:mm --title "标题" (--event-node <id> | --subcategory <id>) [其他参数]
+
+用途:
+  - 写单条时间轴事件，不必手写 raw JSON
+  - 适合把一个明确的时间块快速追加进当天 timeline
+  - 如果要一次写多条事件，或直接替换整批 events，继续用 timeline:write
+
+常用参数:
+  --date YYYY-MM-DD
+  --start HH:mm | 完整时间戳
+  --end HH:mm | 完整时间戳
+  --title "事件标题"
+  --note "详细备注"        可选；也可用 --stdin 从标准输入读 note
+  --event-node <id>        与 taxonomy 里的 eventNode 对应
+  --subcategory <id>       不传 event-node 时至少提供它
+  --category <id>          subcategory 无法自动反推时建议一起传
+  --tag <text>             可重复传多次
+  --mode merge|replace     默认 merge
+  --finalize               按 timeline-for-agent 的 finalize 语义写入
+
+示例:
+  npm run timeline:event -- --date 2026-04-10 --start 09:30 --end 10:15 --title "看 Codeksei 提交历史" --subcategory work.dev --category work --note "为了补日记和时间线先核对最近改动。"
+  @'
+补充背景和为什么要记录这段。
+'@ | npm run timeline:event -- --date 2026-04-10 --start 10:20 --end 10:45 --title "整理营养师笔记结构" --subcategory study.reading --stdin
+`);
+}
+
+module.exports = {
+  runTimelineEventCommand,
+  parseTimelineEventArgs,
+  buildTimelineEventWriteArgs,
+  normalizeTimelineEventTimestamp,
+};