codeksei 0.1.0

package/src/core/workspace-bootstrap.js

@@ -0,0 +1,338 @@
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_BOOTSTRAP_PROFILE = Object.freeze({
+  primaryFiles: [
+    {
+      path: "AGENTS.md",
+      role: "workspace routing and boundary contract",
+    },
+    {
+      path: "README.md",
+      role: "workspace overview and operating instructions",
+    },
+    {
+      path: "Home.md",
+      role: "workspace home and current control page",
+    },
+    {
+      path: ".codex/AGENT_GUIDE.md",
+      role: "agent write/update rules for this workspace",
+    },
+  ],
+  conditionalFiles: [
+    {
+      path: ".codex/timeline/README.md",
+      role: "timeline write/read contract for this workspace",
+      when: "timeline read/write/build/screenshot work",
+    },
+  ],
+  recentFiles: [],
+});
+
+let workspaceBootstrapConfigCache = {
+  filePath: "",
+  mtimeMs: -1,
+  value: {},
+};
+
+function buildWorkspaceContinuityInstructions(workspaceRoot, config = {}) {
+  const normalizedWorkspaceRoot = normalizeWorkspaceRoot(workspaceRoot);
+  if (!normalizedWorkspaceRoot) {
+    return "";
+  }
+
+  const profile = resolveWorkspaceBootstrapProfile(normalizedWorkspaceRoot, config);
+  // Keep the bootstrap read set intentionally narrow and curated. This path is
+  // supposed to rehydrate durable context for a thread, not silently turn a
+  // workspace switch into a broad vault scan.
+  const primaryFiles = collectExistingFiles(normalizedWorkspaceRoot, profile.primaryFiles);
+  const recentFiles = collectRecentFiles(normalizedWorkspaceRoot, profile.recentFiles);
+  const conditionalFiles = collectExistingFiles(normalizedWorkspaceRoot, profile.conditionalFiles);
+
+  const primarySequence = primaryFiles.concat(recentFiles);
+  if (!primarySequence.length && !conditionalFiles.length) {
+    return "";
+  }
+
+  const lines = [
+    "This workspace keeps durable continuity in local notes.",
+    `Current workspace root: ${normalizedWorkspaceRoot}`,
+  ];
+
+  if (primarySequence.length) {
+    lines.push(
+      "Before your first substantive reply in this workspace, recover context from these files in order:"
+    );
+    for (const [index, file] of primarySequence.entries()) {
+      lines.push(`${index + 1}. ${file.absolutePath} - ${file.role}`);
+    }
+  }
+
+  for (const group of groupConditionalFiles(conditionalFiles)) {
+    lines.push("");
+    lines.push(`If the current user request touches ${group.when}, also read:`);
+    for (const file of group.files) {
+      lines.push(`- ${file.absolutePath} - ${file.role}`);
+    }
+  }
+
+  lines.push("");
+  lines.push("Use AGENTS / Home / workspace README as durable truth.");
+  if (recentFiles.length) {
+    lines.push("Treat any auto-discovered recent note only as recent context, not as a permanent rulebook.");
+  }
+  lines.push("Do not paste these file paths or summarize them back unless the user explicitly asks.");
+  return lines.join("\n").trim();
+}
+
+function resolveWorkspaceBootstrapProfile(workspaceRoot, config = {}) {
+  const externalConfig = loadWorkspaceBootstrapConfig(config);
+  const externalDefaults = externalConfig.defaults || externalConfig.default || {};
+  const baseProfile = mergeProfiles(DEFAULT_BOOTSTRAP_PROFILE, externalDefaults);
+  const workspaceOverrides = selectWorkspaceOverrides(externalConfig.workspaces, workspaceRoot);
+  return mergeProfiles(baseProfile, workspaceOverrides || {});
+}
+
+function loadWorkspaceBootstrapConfig(config = {}) {
+  const filePath = normalizeText(config.workspaceBootstrapConfigFile);
+  if (!filePath) {
+    return {};
+  }
+  let stats = null;
+  try {
+    stats = fs.statSync(filePath);
+  } catch {
+    workspaceBootstrapConfigCache = {
+      filePath: "",
+      mtimeMs: -1,
+      value: {},
+    };
+    return {};
+  }
+
+  if (!stats.isFile()) {
+    return {};
+  }
+
+  const normalizedPath = normalizeDisplayPath(filePath);
+  if (
+    workspaceBootstrapConfigCache.filePath === normalizedPath
+    && workspaceBootstrapConfigCache.mtimeMs === stats.mtimeMs
+  ) {
+    return workspaceBootstrapConfigCache.value;
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const value = parsed && typeof parsed === "object" ? parsed : {};
+    workspaceBootstrapConfigCache = {
+      filePath: normalizedPath,
+      mtimeMs: stats.mtimeMs,
+      value,
+    };
+    return value;
+  } catch {
+    workspaceBootstrapConfigCache = {
+      filePath: normalizedPath,
+      mtimeMs: stats.mtimeMs,
+      value: {},
+    };
+    return {};
+  }
+}
+
+function selectWorkspaceOverrides(workspaces, workspaceRoot) {
+  if (!workspaces || typeof workspaces !== "object") {
+    return null;
+  }
+  const normalizedWorkspaceRoot = normalizeDisplayPath(workspaceRoot);
+  for (const [candidateRoot, profile] of Object.entries(workspaces)) {
+    if (normalizeDisplayPath(candidateRoot) === normalizedWorkspaceRoot) {
+      return profile;
+    }
+  }
+  return null;
+}
+
+function mergeProfiles(baseProfile, overrideProfile) {
+  const override = overrideProfile && typeof overrideProfile === "object" ? overrideProfile : {};
+  return {
+    primaryFiles: hasOwn(override, "primaryFiles")
+      ? normalizeFileCandidates(override.primaryFiles)
+      : normalizeFileCandidates(baseProfile.primaryFiles),
+    conditionalFiles: hasOwn(override, "conditionalFiles")
+      ? normalizeFileCandidates(override.conditionalFiles)
+      : normalizeFileCandidates(baseProfile.conditionalFiles),
+    recentFiles: hasOwn(override, "recentFiles")
+      ? normalizeRecentFileSpecs(override.recentFiles)
+      : normalizeRecentFileSpecs(baseProfile.recentFiles),
+  };
+}
+
+function normalizeFileCandidates(rawCandidates) {
+  const candidates = Array.isArray(rawCandidates) ? rawCandidates : [];
+  return candidates
+    .map((candidate) => normalizeFileCandidate(candidate))
+    .filter(Boolean);
+}
+
+function normalizeFileCandidate(rawCandidate) {
+  const candidate = rawCandidate && typeof rawCandidate === "object" ? rawCandidate : {};
+  const relativePath = normalizeRelativePath(candidate.path || candidate.relativePath);
+  if (!relativePath) {
+    return null;
+  }
+  return {
+    relativePath,
+    role: normalizeText(candidate.role) || "workspace entry file",
+    when: normalizeText(candidate.when),
+  };
+}
+
+function normalizeRecentFileSpecs(rawSpecs) {
+  const specs = Array.isArray(rawSpecs) ? rawSpecs : [];
+  return specs
+    .map((spec) => normalizeRecentFileSpec(spec))
+    .filter(Boolean);
+}
+
+function normalizeRecentFileSpec(rawSpec) {
+  const spec = rawSpec && typeof rawSpec === "object" ? rawSpec : {};
+  const directory = normalizeRelativePath(spec.directory);
+  const patternText = normalizeText(spec.pattern);
+  if (!directory || !patternText) {
+    return null;
+  }
+  let pattern = null;
+  try {
+    pattern = new RegExp(patternText);
+  } catch {
+    return null;
+  }
+  const maxCount = Math.max(1, Number.parseInt(spec.maxCount, 10) || 1);
+  return {
+    directory,
+    pattern,
+    role: normalizeText(spec.role) || "newest workspace note",
+    maxCount,
+  };
+}
+
+function collectExistingFiles(workspaceRoot, candidates) {
+  const normalizedCandidates = Array.isArray(candidates) ? candidates : [];
+  const files = [];
+  for (const candidate of normalizedCandidates) {
+    const relativePath = normalizeRelativePath(candidate?.relativePath);
+    if (!relativePath) {
+      continue;
+    }
+    const absolutePath = path.join(workspaceRoot, ...relativePath.split("/"));
+    if (!isReadableFile(absolutePath)) {
+      continue;
+    }
+    files.push({
+      absolutePath: normalizeDisplayPath(absolutePath),
+      role: normalizeText(candidate?.role) || "workspace entry file",
+      when: normalizeText(candidate?.when),
+    });
+  }
+  return files;
+}
+
+function collectRecentFiles(workspaceRoot, specs) {
+  const normalizedSpecs = Array.isArray(specs) ? specs : [];
+  const files = [];
+  for (const spec of normalizedSpecs) {
+    const directoryPath = path.join(workspaceRoot, ...String(spec.directory || "").split("/"));
+    if (!isReadableDirectory(directoryPath)) {
+      continue;
+    }
+    const entries = fs.readdirSync(directoryPath, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && spec.pattern.test(entry.name))
+      .map((entry) => entry.name)
+      .sort((left, right) => right.localeCompare(left))
+      .slice(0, spec.maxCount);
+    for (const entryName of entries) {
+      files.push({
+        absolutePath: normalizeDisplayPath(path.join(directoryPath, entryName)),
+        role: spec.role,
+      });
+    }
+  }
+  return files;
+}
+
+function groupConditionalFiles(files) {
+  const groups = [];
+  const byWhen = new Map();
+  for (const file of Array.isArray(files) ? files : []) {
+    const when = normalizeText(file.when);
+    if (!when) {
+      continue;
+    }
+    if (!byWhen.has(when)) {
+      byWhen.set(when, []);
+      groups.push({
+        when,
+        files: byWhen.get(when),
+      });
+    }
+    byWhen.get(when).push(file);
+  }
+  return groups;
+}
+
+function isReadableFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isReadableDirectory(directoryPath) {
+  try {
+    return fs.statSync(directoryPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function normalizeWorkspaceRoot(workspaceRoot) {
+  const normalized = normalizeText(workspaceRoot);
+  if (!normalized) {
+    return "";
+  }
+  return normalizeDisplayPath(normalized);
+}
+
+function normalizeRelativePath(value) {
+  if (Array.isArray(value)) {
+    return value
+      .map((segment) => normalizeText(segment))
+      .filter(Boolean)
+      .join("/");
+  }
+  return normalizeText(value)
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/\/+$/, "");
+}
+
+function normalizeDisplayPath(targetPath) {
+  return normalizeText(targetPath).replace(/\\/g, "/");
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value || {}, key);
+}
+
+module.exports = {
+  buildWorkspaceContinuityInstructions,
+};

package/src/index.js

@@ -0,0 +1,270 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const dotenv = require("dotenv");
+
+const {
+  PACKAGE_NAME,
+  ensureCompatHomeEnv,
+  ensureStateDirectory,
+  listEnvFileCandidates,
+} = require("./core/branding");
+const { readConfig } = require("./core/config");
+const { renderInstructionTemplate } = require("./core/instructions-template");
+const { CyberbossApp } = require("./core/app");
+const { createTimelineIntegration } = require("./integrations/timeline");
+const { runDiaryWriteCommand } = require("./app/diary-write-cli");
+const { runReminderWriteCommand } = require("./app/reminder-write-cli");
+const { runChannelSendFileCommand } = require("./app/channel-send-file-cli");
+const { runNoteAutoCommand, runNoteMaybeCommand } = require("./app/note-auto-cli");
+const { runNoteSyncCommand } = require("./app/note-sync-cli");
+const { runProjectRadarCommand } = require("./app/project-radar-cli");
+const { runReviewCommand } = require("./app/review-cli");
+const { runTimelineEventCommand } = require("./app/timeline-event-cli");
+const { runTimelineScreenshotCommand } = require("./app/timeline-screenshot-cli");
+const { runSystemCheckinPoller } = require("./app/system-checkin-poller");
+const { runSystemSendCommand } = require("./app/system-send-cli");
+const {
+  buildTerminalHelpText,
+  buildTerminalTopicHelp,
+  isPlannedTerminalTopic,
+} = require("./core/command-registry");
+
+function ensureDefaultStateDirectory() {
+  ensureStateDirectory();
+}
+
+function loadEnv() {
+  ensureDefaultStateDirectory();
+  const candidates = listEnvFileCandidates();
+  for (const envPath of candidates) {
+    if (!fs.existsSync(envPath)) {
+      continue;
+    }
+    dotenv.config({ path: envPath });
+    return;
+  }
+  dotenv.config();
+}
+
+function ensureRuntimeEnv() {
+  ensureCompatHomeEnv({ fallbackRoot: path.resolve(__dirname, "..") });
+}
+
+function ensureBootstrapFiles(config) {
+  ensureInstructionsTemplate(config);
+}
+
+function ensureInstructionsTemplate(config) {
+  const filePath = typeof config?.weixinInstructionsFile === "string"
+    ? config.weixinInstructionsFile.trim()
+    : "";
+  if (!filePath || fs.existsSync(filePath)) {
+    return;
+  }
+
+  const templatePath = path.resolve(__dirname, "..", "templates", "weixin-instructions.md");
+  let template = "";
+  try {
+    template = fs.readFileSync(templatePath, "utf8");
+  } catch {
+    return;
+  }
+
+  const userName = String(config?.userName || "").trim() || "用户";
+  const content = renderInstructionTemplate(template, {
+    ...config,
+    userName,
+  }).trimEnd() + "\n";
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+}
+
+function printHelp() {
+  console.log(buildTerminalHelpText());
+}
+
+let runtimeErrorHooksInstalled = false;
+
+function installRuntimeErrorHooks() {
+  if (runtimeErrorHooksInstalled) {
+    return;
+  }
+  runtimeErrorHooksInstalled = true;
+
+  process.on("unhandledRejection", (reason) => {
+    const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+    console.error(`[${PACKAGE_NAME}] unhandled rejection ${message}`);
+  });
+
+  process.on("uncaughtException", (error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    console.error(`[${PACKAGE_NAME}] uncaught exception ${message}`);
+    process.exitCode = 1;
+  });
+}
+
+async function main() {
+  loadEnv();
+  ensureRuntimeEnv();
+  installRuntimeErrorHooks();
+  const argv = process.argv.slice(2);
+  const config = readConfig();
+  ensureBootstrapFiles(config);
+  const command = config.mode || "help";
+  const subcommand = argv[1] || "";
+  let app = null;
+  const getApp = () => {
+    if (!app) {
+      app = new CyberbossApp(config);
+    }
+    return app;
+  };
+
+  if (command === "help" || command === "--help" || command === "-h") {
+    const topicHelp = subcommand ? buildTerminalTopicHelp(subcommand) : "";
+    console.log(topicHelp || buildTerminalHelpText());
+    return;
+  }
+
+  if (isPlannedTerminalTopic(command)) {
+    const topicHelp = buildTerminalTopicHelp(command);
+    const subcommandArgs = argv.slice(2);
+    const wantsSubcommandHelp = subcommandArgs.includes("--help") || subcommandArgs.includes("-h");
+    if (subcommand === "help" || !subcommand) {
+      console.log(topicHelp);
+      return;
+    }
+    if (command === "diary" && subcommand === "write") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runDiaryWriteCommand(config);
+      return;
+    }
+    if (command === "reminder" && subcommand === "write") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runReminderWriteCommand(config);
+      return;
+    }
+    if (command === "system" && subcommand === "send") {
+      await runSystemSendCommand(config);
+      return;
+    }
+    if (command === "system" && subcommand === "checkin-poller") {
+      await runSystemCheckinPoller(config);
+      return;
+    }
+    if (command === "channel" && subcommand === "send-file") {
+      await runChannelSendFileCommand(getApp());
+      return;
+    }
+    if (command === "note" && subcommand === "sync") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runNoteSyncCommand(config);
+      return;
+    }
+    if (command === "note" && subcommand === "auto") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runNoteAutoCommand(config);
+      return;
+    }
+    if (command === "note" && subcommand === "maybe") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      runNoteMaybeCommand(config);
+      return;
+    }
+    if (command === "project" && subcommand === "radar") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runProjectRadarCommand(config);
+      return;
+    }
+    if (command === "review" && subcommand === "weekly") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runReviewCommand(config, "weekly");
+      return;
+    }
+    if (command === "review" && subcommand === "nightly") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runReviewCommand(config, "nightly");
+      return;
+    }
+    if (command === "review" && subcommand === "monthly") {
+      if (wantsSubcommandHelp) {
+        console.log(topicHelp);
+        return;
+      }
+      await runReviewCommand(config, "monthly");
+      return;
+    }
+  }
+
+  if (command === "timeline") {
+    const timelineIntegration = createTimelineIntegration(config);
+    if (!subcommand || subcommand === "help") {
+      console.log(buildTerminalTopicHelp("timeline"));
+      return;
+    }
+    if (subcommand === "event") {
+      await runTimelineEventCommand(timelineIntegration, argv.slice(2));
+      return;
+    }
+    if (subcommand === "screenshot") {
+      const screenshotArgs = argv.slice(2);
+      if (screenshotArgs.includes("--help") || screenshotArgs.includes("-h")) {
+        await timelineIntegration.runSubcommand(subcommand, screenshotArgs);
+        return;
+      }
+      await runTimelineScreenshotCommand(config, argv.slice(2));
+      return;
+    }
+    await timelineIntegration.runSubcommand(subcommand, argv.slice(2));
+    return;
+  }
+
+  if (command === "doctor") {
+    getApp().printDoctor();
+    return;
+  }
+
+  if (command === "login") {
+    await getApp().login();
+    return;
+  }
+
+  if (command === "accounts") {
+    getApp().printAccounts();
+    return;
+  }
+
+  if (command === "start") {
+    await getApp().start();
+    return;
+  }
+
+  throw new Error(`未知命令: ${command}`);
+}
+
+module.exports = { main };