codeksei 0.1.0

package/src/app/note-auto-cli.js

@@ -0,0 +1,201 @@
+const {
+  ensureDurableNoteSections,
+  inspectDurableNoteRouting,
+  resolveDurableNoteRoute,
+} = require("../core/durable-note-schema");
+const { syncNoteFile } = require("../core/note-sync");
+
+async function runNoteAutoCommand(config, args = process.argv.slice(4)) {
+  const options = parseNoteAutoArgs(args);
+  if (options.help) {
+    printNoteAutoHelp();
+    return;
+  }
+
+  const text = await resolveBody(options);
+  if (!text) {
+    throw new Error("note 内容不能为空，传 --text 或通过 stdin 输入");
+  }
+
+  const route = resolveDurableNoteRoute(config, options);
+  const schemaResult = ensureDurableNoteSections(route.filePath, route.sections);
+  const result = syncNoteFile({
+    filePath: route.filePath,
+    section: route.section,
+    text,
+    style: route.style,
+    slot: route.slot,
+    maxItems: route.maxItems,
+  });
+
+  const action = result.changed ? "updated" : "noop";
+  console.log(`note auto ${action}: ${result.filePath} [${route.family}:${route.kind} -> ${route.section}]`);
+  if (schemaResult.changed) {
+    console.log(`schema ensured: ${schemaResult.filePath} (${schemaResult.createdSections.join(", ")})`);
+  }
+}
+
+function runNoteMaybeCommand(config, args = process.argv.slice(4)) {
+  const options = parseNoteAutoArgs(args);
+  if (options.help) {
+    printNoteMaybeHelp();
+    return;
+  }
+
+  const inspection = inspectDurableNoteRouting(config, options);
+  if (options.json) {
+    console.log(JSON.stringify(inspection, null, 2));
+    return;
+  }
+  console.log(formatInspection(inspection));
+}
+
+function parseNoteAutoArgs(args) {
+  const options = {
+    help: false,
+    json: false,
+    project: "",
+    scope: "",
+    kind: "",
+    text: "",
+    useStdin: false,
+  };
+
+  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 === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (arg === "--stdin") {
+      options.useStdin = 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 === "--project") {
+      options.project = value;
+    } else if (arg === "--scope") {
+      options.scope = value;
+    } else if (arg === "--kind") {
+      options.kind = value;
+    } else if (arg === "--text") {
+      options.text = value;
+    } else {
+      throw new Error(`未知参数: ${arg}`);
+    }
+    index += 1;
+  }
+
+  return options;
+}
+
+async function resolveBody(options) {
+  const inline = String(options.text || "").trim();
+  if (inline) {
+    return inline;
+  }
+  if (!options.useStdin && process.stdin.isTTY) {
+    return "";
+  }
+  return readStdin();
+}
+
+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.trim()));
+    process.stdin.on("error", reject);
+  });
+}
+
+function formatInspection(inspection) {
+  if (inspection.mode === "overview") {
+    const lines = [
+      "durable note 路由概览：",
+      "",
+      `workspace: ${inspection.workspaceRoot}`,
+      `project kinds: ${inspection.project.kinds.join(", ") || "none"}`,
+      `tracked projects: ${inspection.project.availableProjects.join(", ") || "none"}`,
+    ];
+    for (const [scope, info] of Object.entries(inspection.scopes || {})) {
+      lines.push("");
+      lines.push(`[${scope}] ${info.filePath}`);
+      lines.push(`kinds: ${info.kinds.join(", ") || "none"}`);
+      lines.push(`sections: ${info.sections.join(" / ") || "none"}`);
+    }
+    return lines.join("\n");
+  }
+
+  if (inspection.mode === "family") {
+    return [
+      `durable note family: ${inspection.family}`,
+      `file: ${inspection.filePath}`,
+      `kinds: ${inspection.kinds.join(", ") || "none"}`,
+      `sections: ${inspection.sections.join(" / ") || "none"}`,
+    ].join("\n");
+  }
+
+  return [
+    `durable note route: ${inspection.family}:${inspection.route.kind}`,
+    `file: ${inspection.filePath}`,
+    `section: ${inspection.route.section}`,
+    `style: ${inspection.route.style}`,
+    `slot: ${inspection.route.slot || "-"}`,
+    `maxItems: ${inspection.route.maxItems || 0}`,
+  ].join("\n");
+}
+
+function printNoteAutoHelp() {
+  console.log([
+    "用法: npm run note:auto -- (--project <slug> | --scope <name>) --kind <kind> [--text \"内容\" | --stdin]",
+    "",
+    "说明：",
+    "  按 workspace 级 durable note schema 自动决定 file / section / style / slot。",
+    "  代码项目常用 --project；生活助理、灵感等 durable note 用 --scope。",
+    "",
+    "示例：",
+    "  npm run note:auto -- --project <slug> --kind recent --text \"补了 note:auto / note:maybe 路由层\"",
+    "  npm run note:auto -- --project <slug> --kind status --text \"当前已接上 durable note schema，下一步观察真实线程里的使用手感。\"",
+    "  npm run note:auto -- --scope assistant --kind preference --text \"默认先接住，再定向，再推进；少 mirror，少催债式 check-in。\"",
+    "  npm run note:auto -- --scope inspiration --kind idea --text \"做一个只在切换点发力的 transition mode，让主动提醒更像接线而不是催债。\"",
+  ].join("\n"));
+}
+
+function printNoteMaybeHelp() {
+  console.log([
+    "用法: npm run note:maybe -- [--project <slug> | --scope <name>] [--kind <kind>] [--json]",
+    "",
+    "说明：",
+    "  只看 durable note 路由，不落盘。",
+    "  不传参数时列出当前 workspace 可用 scope、kinds 和 tracked projects。",
+    "",
+    "示例：",
+    "  npm run note:maybe",
+    "  npm run note:maybe -- --project <slug>",
+    "  npm run note:maybe -- --scope assistant --kind preference",
+    "  npm run note:maybe -- --scope inspiration --json",
+  ].join("\n"));
+}
+
+module.exports = {
+  parseNoteAutoArgs,
+  runNoteAutoCommand,
+  runNoteMaybeCommand,
+};

package/src/app/note-sync-cli.js

@@ -0,0 +1,130 @@
+const {
+  resolveNoteSyncTarget,
+  syncNoteFile,
+} = require("../core/note-sync");
+
+async function runNoteSyncCommand(config, args = process.argv.slice(4)) {
+  const options = parseNoteSyncArgs(args);
+  if (options.help) {
+    printNoteSyncHelp();
+    return;
+  }
+
+  const text = await resolveBody(options);
+  if (!text) {
+    throw new Error("note 内容不能为空，传 --text 或通过 stdin 输入");
+  }
+
+  const target = resolveNoteSyncTarget(config, options);
+  const result = syncNoteFile({
+    filePath: target.filePath,
+    section: options.section,
+    text,
+    style: options.style,
+    slot: options.slot,
+    maxItems: options.maxItems,
+  });
+
+  const action = result.changed ? "updated" : "noop";
+  console.log(`note ${action}: ${result.filePath} [${options.section}]`);
+}
+
+function parseNoteSyncArgs(args) {
+  const options = {
+    help: false,
+    project: "",
+    path: "",
+    section: "",
+    text: "",
+    style: "bullet",
+    slot: "",
+    maxItems: "",
+    useStdin: false,
+  };
+
+  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 === "--stdin") {
+      options.useStdin = 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 === "--project") {
+      options.project = value;
+    } else if (arg === "--path") {
+      options.path = value;
+    } else if (arg === "--section") {
+      options.section = value;
+    } else if (arg === "--text") {
+      options.text = value;
+    } else if (arg === "--style") {
+      options.style = value;
+    } else if (arg === "--slot") {
+      options.slot = value;
+    } else if (arg === "--max-items") {
+      options.maxItems = value;
+    } else {
+      throw new Error(`未知参数: ${arg}`);
+    }
+    index += 1;
+  }
+
+  return options;
+}
+
+async function resolveBody(options) {
+  const inline = String(options.text || "").trim();
+  if (inline) {
+    return inline;
+  }
+  if (!options.useStdin && process.stdin.isTTY) {
+    return "";
+  }
+  return readStdin();
+}
+
+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.trim()));
+    process.stdin.on("error", reject);
+  });
+}
+
+function printNoteSyncHelp() {
+  console.log([
+    "用法: npm run note:sync -- (--project <slug> | --path <path>) --section <标题> [--text \"内容\" | --stdin] [--style bullet|paragraph] [--slot <id>] [--max-items N]",
+    "",
+    "说明：",
+    "  轻量把一条 durable 摘要写回指定 note 的指定 section。",
+    "  默认 style 是 bullet；传 --slot 时会用受控 block 替换同一槽位的旧内容。",
+    "  不传 --slot 时会做轻量追加，并对相同内容去重。",
+    "",
+    "示例：",
+    "  npm run note:sync -- --project <slug> --section \"最近动作\" --text \"把微信 prompt 收口为更温柔的 chief-of-staff 风格\" --max-items 6",
+    "  npm run note:sync -- --project <slug> --section \"当前状态\" --slot current-status --style paragraph --text \"当前默认主 workspace 是 Website，shared bridge 正常运行。\"",
+    "  npm run note:sync -- --path \"项目/Codeksei 生活助理/README.md\" --section \"当前定位\" --text \"默认先接住，再定向，再推进，不做催债式主动提醒。\"",
+  ].join("\n"));
+}
+
+module.exports = {
+  parseNoteSyncArgs,
+  runNoteSyncCommand,
+};

package/src/app/project-radar-cli.js

@@ -0,0 +1,165 @@
+const { collectProjectRadars, listTrackedProjects, loadProjectRadarConfig } = require("../core/project-radar");
+
+async function runProjectRadarCommand(config) {
+  const options = parseProjectRadarArgs(process.argv.slice(4));
+  if (options.help) {
+    printProjectRadarHelp(config);
+    return;
+  }
+
+  if (options.list) {
+    const radarConfig = loadProjectRadarConfig(config);
+    const tracked = listTrackedProjects(config);
+    if (options.json) {
+      console.log(JSON.stringify({
+        workspaceRoot: radarConfig.workspaceRoot,
+        configFile: radarConfig.configFile,
+        projects: tracked,
+      }, null, 2));
+      return;
+    }
+    printProjectList(radarConfig, tracked);
+    return;
+  }
+
+  const result = collectProjectRadars(config, options);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(renderProjectRadarsText(result));
+}
+
+function parseProjectRadarArgs(args) {
+  const options = {
+    help: false,
+    list: false,
+    json: false,
+    project: "",
+    commits: 5,
+    changes: 20,
+  };
+
+  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 === "--list") {
+      options.list = true;
+      continue;
+    }
+    if (token === "--json") {
+      options.json = 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 === "project") {
+      options.project = value.trim();
+    } else if (key === "commits") {
+      options.commits = value.trim();
+    } else if (key === "changes") {
+      options.changes = value.trim();
+    } else {
+      throw new Error(`未知参数: ${token}`);
+    }
+    index += 1;
+  }
+
+  return options;
+}
+
+function printProjectRadarHelp(config = {}) {
+  console.log([
+    "用法: npm run project:radar -- [--list] [--project <slug>] [--json] [--commits 5] [--changes 20]",
+    "",
+    "说明：",
+    "  默认从当前 workspace 的 .codex/code-projects.json 读取已跟踪代码项目。",
+    `  当前配置文件: ${config.projectRadarConfigFile || "(auto)"}`,
+    "",
+    "示例：",
+    "  npm run project:radar -- --list",
+    "  npm run project:radar -- --project <slug> --json",
+    "  npm run project:radar -- --project engineering-issues --commits 8 --changes 30",
+  ].join("\n"));
+}
+
+function printProjectList(radarConfig, trackedProjects) {
+  const lines = [
+    `workspace: ${radarConfig.workspaceRoot}`,
+    `config: ${radarConfig.configFile}`,
+    "",
+    "tracked projects:",
+  ];
+  for (const project of trackedProjects) {
+    lines.push(`- ${project.slug} | ${project.title}`);
+    lines.push(`  repo: ${project.repoRoot}`);
+    lines.push(`  note: ${project.notePath}`);
+  }
+  console.log(lines.join("\n"));
+}
+
+function renderProjectRadarsText(result) {
+  const lines = [
+    `workspace: ${result.workspaceRoot}`,
+    `config: ${result.configFile}`,
+    `generatedAt: ${result.generatedAt}`,
+  ];
+
+  for (const project of result.projects) {
+    lines.push("");
+    lines.push(`## ${project.slug} | ${project.title}`);
+    lines.push(`repo: ${project.repoRoot}`);
+    lines.push(`note: ${project.notePath || "(none)"}`);
+    if (project.timelineLabel) {
+      lines.push(`timeline: ${project.timelineLabel}`);
+    }
+
+    if (project.readFirst.length) {
+      lines.push("readFirst:");
+      for (const file of project.readFirst) {
+        lines.push(`- [${file.kind}] ${file.path}${file.exists ? "" : " (missing)"}`);
+      }
+    }
+
+    if (!project.git.ok) {
+      lines.push(`git: ${project.git.message}`);
+      continue;
+    }
+
+    lines.push(`branch: ${project.git.branch || "(unknown)"}`);
+    if (project.git.upstream) {
+      lines.push(`upstream: ${project.git.upstream} | ahead=${project.git.ahead} behind=${project.git.behind}`);
+    }
+    lines.push(
+      `dirty: ${project.git.dirty ? "yes" : "no"} | staged=${project.git.summary.staged} unstaged=${project.git.summary.unstaged} untracked=${project.git.summary.untracked} conflicted=${project.git.summary.conflicted}`
+    );
+    if (project.git.statusEntries.length) {
+      lines.push("changes:");
+      for (const entry of project.git.statusEntries) {
+        lines.push(`- ${entry.code} ${entry.path}`);
+      }
+    }
+    if (project.git.recentCommits.length) {
+      lines.push("recentCommits:");
+      for (const commit of project.git.recentCommits) {
+        lines.push(`- ${commit.shortHash} ${commit.committedAt} ${commit.subject}`);
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = { runProjectRadarCommand };

package/src/app/reminder-write-cli.js

@@ -0,0 +1,210 @@
+const crypto = require("crypto");
+
+const { resolveSelectedAccount } = require("../adapters/channel/weixin/account-store");
+const { loadPersistedContextTokens } = require("../adapters/channel/weixin/context-token-store");
+const { ReminderQueueStore } = require("../adapters/channel/weixin/reminder-queue-store");
+const { SessionStore } = require("../adapters/runtime/codex/session-store");
+const { resolvePreferredSenderId } = require("../core/default-targets");
+
+const DELAY_UNIT_MS = {
+  s: 1_000,
+  m: 60_000,
+  h: 60 * 60_000,
+  d: 24 * 60 * 60_000,
+};
+const LOCAL_TIMEZONE_OFFSET = "+08:00";
+
+async function runReminderWriteCommand(config) {
+  const args = process.argv.slice(4);
+  const options = parseArgs(args);
+  const body = await resolveBody(options);
+  if (!body) {
+    throw new Error("提醒内容不能为空，传 --text 或通过 stdin 输入");
+  }
+
+  const dueAtMs = resolveDueAtMs(options);
+  if (!Number.isFinite(dueAtMs) || dueAtMs <= Date.now()) {
+    throw new Error("缺少有效时间，使用 --delay 30s|10m|1h30m|2d4h20m 或 --at 2026-04-07T21:30+08:00");
+  }
+
+  const account = resolveSelectedAccount(config);
+  const sessionStore = new SessionStore({ filePath: config.sessionsFile });
+  const senderId = resolvePreferredSenderId({
+    config,
+    accountId: account.accountId,
+    explicitUser: options.user,
+    sessionStore,
+  });
+  if (!senderId) {
+    throw new Error("无法确定 reminder 的微信用户，传 --user 或先让唯一活跃用户和 bot 聊过一次");
+  }
+
+  const contextTokens = loadPersistedContextTokens(config, account.accountId);
+  const contextToken = String(contextTokens[senderId] || "").trim();
+  if (!contextToken) {
+    throw new Error(`找不到 ${senderId} 的 context_token，先让这个用户和 bot 聊过一次`);
+  }
+
+  const queue = new ReminderQueueStore({ filePath: config.reminderQueueFile });
+  const reminder = queue.enqueue({
+    id: crypto.randomUUID(),
+    accountId: account.accountId,
+    senderId,
+    contextToken,
+    text: body,
+    dueAtMs,
+    createdAt: new Date().toISOString(),
+  });
+  console.log(`reminder queued: ${reminder.id}`);
+}
+
+function parseArgs(args) {
+  const options = {
+    delay: "",
+    at: "",
+    text: "",
+    user: "",
+    useStdin: false,
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--delay") {
+      options.delay = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--at") {
+      options.at = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--text") {
+      options.text = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--user") {
+      options.user = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--stdin") {
+      options.useStdin = true;
+      continue;
+    }
+    throw new Error(`未知参数: ${arg}`);
+  }
+  return options;
+}
+
+function resolveDueAtMs(options) {
+  const delayMs = parseDelay(options.delay);
+  const scheduledAtMs = parseAbsoluteTime(options.at);
+  if (delayMs && scheduledAtMs) {
+    throw new Error("--delay 和 --at 不能同时传");
+  }
+  if (delayMs) {
+    return Date.now() + delayMs;
+  }
+  if (scheduledAtMs) {
+    return scheduledAtMs;
+  }
+  return 0;
+}
+
+function parseDelay(rawValue) {
+  const normalized = String(rawValue || "").trim().toLowerCase();
+  if (!normalized) {
+    return 0;
+  }
+
+  let totalMs = 0;
+  let index = 0;
+  while (index < normalized.length) {
+    while (index < normalized.length && /\s/.test(normalized[index])) {
+      index += 1;
+    }
+    if (index >= normalized.length) {
+      break;
+    }
+
+    const match = normalized.slice(index).match(/^(\d+)\s*([smhd])/);
+    if (!match) {
+      return 0;
+    }
+
+    const amount = Number.parseInt(match[1], 10);
+    const unitMs = DELAY_UNIT_MS[match[2]] || 0;
+    if (!Number.isFinite(amount) || amount <= 0 || !unitMs) {
+      return 0;
+    }
+
+    totalMs += amount * unitMs;
+    index += match[0].length;
+  }
+
+  return totalMs > 0 ? totalMs : 0;
+}
+
+function parseAbsoluteTime(rawValue) {
+  const normalized = String(rawValue || "").trim();
+  if (!normalized) {
+    return 0;
+  }
+
+  const normalizedIso = normalizeAbsoluteTimeString(normalized);
+  const parsed = Date.parse(normalizedIso);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function normalizeAbsoluteTimeString(value) {
+  const normalized = String(value || "").trim();
+  if (!normalized) {
+    return "";
+  }
+
+  if (/([zZ]|[+-]\d{2}:\d{2})$/.test(normalized)) {
+    return normalized.replace(" ", "T");
+  }
+
+  const dateTimeMatch = normalized.match(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}(?::\d{2})?)$/);
+  if (dateTimeMatch) {
+    return `${dateTimeMatch[1]}T${dateTimeMatch[2]}${LOCAL_TIMEZONE_OFFSET}`;
+  }
+
+  const dateOnlyMatch = normalized.match(/^(\d{4}-\d{2}-\d{2})$/);
+  if (dateOnlyMatch) {
+    return `${dateOnlyMatch[1]}T09:00:00${LOCAL_TIMEZONE_OFFSET}`;
+  }
+
+  return normalized;
+}
+
+async function resolveBody(options) {
+  const inlineText = normalizeBody(options.text);
+  if (inlineText) {
+    return inlineText;
+  }
+  if (!options.useStdin && process.stdin.isTTY) {
+    return "";
+  }
+  return normalizeBody(await readStdin());
+}
+
+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 normalizeBody(value) {
+  return String(value || "").replace(/\r\n/g, "\n").trim();
+}
+
+module.exports = { runReminderWriteCommand };