codeksei 0.1.0

package/src/core/default-targets.js

@@ -0,0 +1,163 @@
+const { loadPersistedContextTokens } = require("../adapters/channel/weixin/context-token-store");
+
+function resolvePreferredSenderId({
+  config,
+  accountId,
+  explicitUser = "",
+  sessionStore = null,
+}) {
+  const normalizedExplicitUser = normalizeText(explicitUser);
+  if (normalizedExplicitUser) {
+    return normalizedExplicitUser;
+  }
+
+  const configuredUsers = Array.isArray(config?.allowedUserIds)
+    ? config.allowedUserIds.map((value) => normalizeText(value)).filter(Boolean)
+    : [];
+  if (configuredUsers.length) {
+    return configuredUsers[0];
+  }
+
+  const bindingCandidates = collectBindingSenderIds({ config, accountId, sessionStore });
+  if (bindingCandidates.length === 1) {
+    return bindingCandidates[0];
+  }
+
+  const persistedUserIds = Object.keys(loadPersistedContextTokens(config, accountId) || {})
+    .map((value) => normalizeText(value))
+    .filter(Boolean);
+  if (persistedUserIds.length === 1) {
+    return persistedUserIds[0];
+  }
+
+  return "";
+}
+
+function resolvePreferredWorkspaceRoot({
+  config,
+  accountId,
+  senderId = "",
+  explicitWorkspace = "",
+  sessionStore = null,
+}) {
+  const normalizedExplicitWorkspace = normalizeText(explicitWorkspace);
+  if (normalizedExplicitWorkspace) {
+    return normalizedExplicitWorkspace;
+  }
+
+  const normalizedSenderId = normalizeText(senderId);
+  const normalizedAccountId = normalizeText(accountId);
+  const store = sessionStore && typeof sessionStore.getBinding === "function"
+    ? sessionStore
+    : null;
+
+  if (store && normalizedSenderId && normalizedAccountId) {
+    const bindingKey = store.buildBindingKey({
+      workspaceId: config.workspaceId,
+      accountId: normalizedAccountId,
+      senderId: normalizedSenderId,
+    });
+    const activeWorkspaceRoot = normalizeText(store.getActiveWorkspaceRoot(bindingKey));
+    if (activeWorkspaceRoot) {
+      return activeWorkspaceRoot;
+    }
+
+    const binding = store.getBinding(bindingKey);
+    const boundWorkspaceRoots = collectWorkspaceRoots(binding);
+    if (boundWorkspaceRoots.length === 1) {
+      return boundWorkspaceRoots[0];
+    }
+  }
+
+  const globalWorkspaceCandidates = collectBindingWorkspaceRoots({ config, accountId, sessionStore: store });
+  if (globalWorkspaceCandidates.length === 1) {
+    return globalWorkspaceCandidates[0];
+  }
+
+  return normalizeText(config?.workspaceRoot);
+}
+
+function collectBindingSenderIds({ config, accountId, sessionStore }) {
+  const store = sessionStore && typeof sessionStore.getBinding === "function"
+    ? sessionStore
+    : null;
+  if (!store) {
+    return [];
+  }
+  const normalizedAccountId = normalizeText(accountId);
+  if (!normalizedAccountId) {
+    return [];
+  }
+
+  const senderIds = new Set();
+  for (const binding of Object.values(store.state?.bindings || {})) {
+    const bindingAccountId = normalizeText(binding?.accountId);
+    const bindingWorkspaceId = normalizeText(binding?.workspaceId);
+    const senderId = normalizeText(binding?.senderId);
+    if (!senderId || bindingAccountId !== normalizedAccountId) {
+      continue;
+    }
+    if (bindingWorkspaceId && bindingWorkspaceId !== normalizeText(config?.workspaceId)) {
+      continue;
+    }
+    senderIds.add(senderId);
+  }
+  return Array.from(senderIds).sort((left, right) => left.localeCompare(right));
+}
+
+function collectBindingWorkspaceRoots({ config, accountId, sessionStore }) {
+  const store = sessionStore && typeof sessionStore.getBinding === "function"
+    ? sessionStore
+    : null;
+  if (!store) {
+    return [];
+  }
+  const normalizedAccountId = normalizeText(accountId);
+  const workspaceRoots = new Set();
+
+  for (const binding of Object.values(store.state?.bindings || {})) {
+    const bindingAccountId = normalizeText(binding?.accountId);
+    const bindingWorkspaceId = normalizeText(binding?.workspaceId);
+    if (bindingAccountId !== normalizedAccountId) {
+      continue;
+    }
+    if (bindingWorkspaceId && bindingWorkspaceId !== normalizeText(config?.workspaceId)) {
+      continue;
+    }
+    for (const workspaceRoot of collectWorkspaceRoots(binding)) {
+      workspaceRoots.add(workspaceRoot);
+    }
+  }
+
+  return Array.from(workspaceRoots).sort((left, right) => left.localeCompare(right));
+}
+
+function collectWorkspaceRoots(binding) {
+  const workspaceRoots = new Set();
+  const activeWorkspaceRoot = normalizeText(binding?.activeWorkspaceRoot);
+  if (activeWorkspaceRoot) {
+    workspaceRoots.add(activeWorkspaceRoot);
+  }
+  for (const workspaceRoot of Object.keys(binding?.threadIdByWorkspaceRoot || {})) {
+    const normalizedWorkspaceRoot = normalizeText(workspaceRoot);
+    if (normalizedWorkspaceRoot) {
+      workspaceRoots.add(normalizedWorkspaceRoot);
+    }
+  }
+  for (const workspaceRoot of Object.keys(binding?.codexParamsByWorkspaceRoot || {})) {
+    const normalizedWorkspaceRoot = normalizeText(workspaceRoot);
+    if (normalizedWorkspaceRoot) {
+      workspaceRoots.add(normalizedWorkspaceRoot);
+    }
+  }
+  return Array.from(workspaceRoots).sort((left, right) => left.localeCompare(right));
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+module.exports = {
+  resolvePreferredSenderId,
+  resolvePreferredWorkspaceRoot,
+};

package/src/core/durable-note-schema.js

@@ -0,0 +1,325 @@
+const fs = require("fs");
+const path = require("path");
+
+const { listTrackedProjects } = require("./project-radar");
+const { appendSection, findSectionRange, resolveNoteSyncTarget } = require("./note-sync");
+
+function loadDurableNoteSchemaConfig(config = {}) {
+  const filePath = normalizeText(config.durableNoteSchemaConfigFile);
+  if (!filePath) {
+    return {};
+  }
+
+  let raw = "";
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (error) {
+    throw new Error(`durable note schema 不是合法 JSON: ${filePath} (${formatErrorMessage(error)})`);
+  }
+}
+
+function resolveDurableNoteProfile(config = {}) {
+  const workspaceRoot = normalizeDisplayPath(path.resolve(String(config.workspaceRoot || process.cwd())));
+  const schemaConfig = loadDurableNoteSchemaConfig(config);
+  const workspaceProfile = selectWorkspaceProfile(schemaConfig.workspaces, workspaceRoot);
+  const projectDefaults = normalizeFamily(workspaceProfile?.projectDefaults);
+  const notes = normalizeNamedFamilies(workspaceProfile?.notes);
+  return {
+    workspaceRoot,
+    projectDefaults,
+    notes,
+  };
+}
+
+function inspectDurableNoteRouting(config = {}, options = {}) {
+  const profile = resolveDurableNoteProfile(config);
+  const project = normalizeText(options.project);
+  const scope = normalizeText(options.scope).toLowerCase();
+  const kind = normalizeText(options.kind).toLowerCase();
+
+  if (project) {
+    const target = resolveNoteSyncTarget(config, { project });
+    return buildInspectionResult({
+      mode: kind ? "route" : "family",
+      familyId: "project",
+      familyLabel: "tracked-project",
+      filePath: target.filePath,
+      sections: profile.projectDefaults.sections,
+      kinds: profile.projectDefaults.kinds,
+      kind,
+      extra: {
+        project: target.label,
+        availableProjects: listTrackedProjects(config).map((entry) => entry.slug),
+      },
+    });
+  }
+
+  if (scope) {
+    const family = profile.notes[scope];
+    if (!family) {
+      throw new Error(`找不到 durable note scope: ${scope}；当前可用 scope: ${listAvailableScopes(profile).join(", ") || "none"}`);
+    }
+    return buildInspectionResult({
+      mode: kind ? "route" : "family",
+      familyId: scope,
+      familyLabel: family.label || scope,
+      filePath: resolveWorkspaceNotePath(profile.workspaceRoot, family.filePath),
+      sections: family.sections,
+      kinds: family.kinds,
+      kind,
+      extra: {},
+    });
+  }
+
+  return {
+    mode: "overview",
+    workspaceRoot: profile.workspaceRoot,
+    project: {
+      availableProjects: listTrackedProjects(config).map((entry) => entry.slug),
+      sections: profile.projectDefaults.sections,
+      kinds: Object.keys(profile.projectDefaults.kinds),
+    },
+    scopes: Object.fromEntries(
+      Object.entries(profile.notes).map(([familyId, family]) => [
+        familyId,
+        {
+          label: family.label || familyId,
+          filePath: resolveWorkspaceNotePath(profile.workspaceRoot, family.filePath),
+          sections: [...family.sections],
+          kinds: Object.keys(family.kinds),
+        },
+      ])
+    ),
+  };
+}
+
+function resolveDurableNoteRoute(config = {}, options = {}) {
+  const inspection = inspectDurableNoteRouting(config, options);
+  if (inspection.mode !== "route") {
+    throw new Error("缺少完整 durable note 路由参数：至少传 --kind，并配合 --project 或 --scope");
+  }
+  return inspection.route;
+}
+
+function ensureDurableNoteSections(filePath, sections = []) {
+  const normalizedPath = normalizeText(filePath);
+  if (!normalizedPath) {
+    throw new Error("durable note filePath 不能为空");
+  }
+  if (!fs.existsSync(normalizedPath)) {
+    throw new Error(`durable note 文件不存在: ${normalizedPath}`);
+  }
+  const stat = fs.statSync(normalizedPath);
+  if (!stat.isFile()) {
+    throw new Error(`durable note 目标不是文件: ${normalizedPath}`);
+  }
+
+  let content = normalizeLineEnding(fs.readFileSync(normalizedPath, "utf8"));
+  let changed = false;
+  const createdSections = [];
+  for (const section of Array.isArray(sections) ? sections : []) {
+    const normalizedSection = normalizeText(section);
+    if (!normalizedSection) {
+      continue;
+    }
+    if (findSectionRange(content, normalizedSection)) {
+      continue;
+    }
+    content = appendSection(content, normalizedSection);
+    createdSections.push(normalizedSection);
+    changed = true;
+  }
+
+  if (changed) {
+    fs.writeFileSync(normalizedPath, ensureTrailingNewline(content), "utf8");
+  }
+  return {
+    changed,
+    createdSections,
+    filePath: normalizeDisplayPath(normalizedPath),
+  };
+}
+
+function buildInspectionResult({ mode, familyId, familyLabel, filePath, sections, kinds, kind, extra }) {
+  const availableKinds = Object.keys(kinds);
+  if (!kind) {
+    return {
+      mode,
+      family: familyId,
+      label: familyLabel,
+      filePath,
+      sections: [...sections],
+      kinds: availableKinds,
+      ...extra,
+    };
+  }
+
+  const matchedKind = kinds[kind];
+  if (!matchedKind) {
+    throw new Error(`scope ${familyId} 不支持 kind: ${kind}；当前可用 kinds: ${availableKinds.join(", ") || "none"}`);
+  }
+
+  return {
+    mode,
+    family: familyId,
+    label: familyLabel,
+    filePath,
+    sections: [...sections],
+    kinds: availableKinds,
+    route: {
+      family: familyId,
+      kind,
+      filePath,
+      section: matchedKind.section,
+      style: matchedKind.style,
+      slot: matchedKind.slot,
+      maxItems: matchedKind.maxItems,
+      sections: [...sections],
+    },
+    ...extra,
+  };
+}
+
+function selectWorkspaceProfile(workspaces, workspaceRoot) {
+  if (!workspaces || typeof workspaces !== "object") {
+    return {};
+  }
+  const normalizedWorkspaceRoot = normalizeDisplayPath(workspaceRoot);
+  for (const [candidateRoot, profile] of Object.entries(workspaces)) {
+    if (normalizeDisplayPath(candidateRoot) === normalizedWorkspaceRoot) {
+      return profile && typeof profile === "object" ? profile : {};
+    }
+  }
+  return {};
+}
+
+function normalizeNamedFamilies(rawFamilies) {
+  if (!rawFamilies || typeof rawFamilies !== "object") {
+    return {};
+  }
+  const entries = Object.entries(rawFamilies)
+    .map(([familyId, rawFamily]) => {
+      const normalizedId = normalizeText(familyId).toLowerCase();
+      const family = normalizeFamily(rawFamily);
+      if (!normalizedId || !family.filePath || !Object.keys(family.kinds).length) {
+        return null;
+      }
+      return [normalizedId, { ...family, label: normalizeText(rawFamily?.label) || normalizedId }];
+    })
+    .filter(Boolean);
+  return Object.fromEntries(entries);
+}
+
+function normalizeFamily(rawFamily) {
+  const family = rawFamily && typeof rawFamily === "object" ? rawFamily : {};
+  return {
+    filePath: normalizeRelativeOrAbsolutePath(family.path),
+    sections: normalizeSections(family.sections),
+    kinds: normalizeKinds(family.kinds),
+  };
+}
+
+function normalizeKinds(rawKinds) {
+  if (!rawKinds || typeof rawKinds !== "object") {
+    return {};
+  }
+  const entries = Object.entries(rawKinds)
+    .map(([kind, rawRoute]) => {
+      const normalizedKind = normalizeText(kind).toLowerCase();
+      const route = normalizeRoute(rawRoute);
+      if (!normalizedKind || !route) {
+        return null;
+      }
+      return [normalizedKind, route];
+    })
+    .filter(Boolean);
+  return Object.fromEntries(entries);
+}
+
+function normalizeRoute(rawRoute) {
+  const route = rawRoute && typeof rawRoute === "object" ? rawRoute : {};
+  const section = normalizeText(route.section);
+  if (!section) {
+    return null;
+  }
+  return {
+    section,
+    style: normalizeText(route.style).toLowerCase() === "paragraph" ? "paragraph" : "bullet",
+    slot: normalizeText(route.slot),
+    maxItems: normalizePositiveInteger(route.maxItems),
+  };
+}
+
+function normalizeSections(rawSections) {
+  return Array.isArray(rawSections)
+    ? rawSections.map((section) => normalizeText(section)).filter(Boolean)
+    : [];
+}
+
+function normalizePositiveInteger(value) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return 0;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function normalizeRelativeOrAbsolutePath(targetPath) {
+  const normalized = normalizeText(targetPath);
+  if (!normalized) {
+    return "";
+  }
+  return normalized.replace(/\\/g, "/");
+}
+
+function resolveWorkspaceNotePath(workspaceRoot, targetPath) {
+  const normalizedTargetPath = normalizeText(targetPath);
+  if (!normalizedTargetPath) {
+    return "";
+  }
+  if (path.isAbsolute(normalizedTargetPath)) {
+    return normalizeDisplayPath(path.resolve(normalizedTargetPath));
+  }
+  return normalizeDisplayPath(path.resolve(workspaceRoot, ...normalizedTargetPath.split("/")));
+}
+
+function listAvailableScopes(profile) {
+  return Object.keys(profile.notes || {});
+}
+
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeDisplayPath(targetPath) {
+  return normalizeText(targetPath).replace(/\\/g, "/");
+}
+
+function normalizeLineEnding(value) {
+  return String(value || "").replace(/\r\n/g, "\n");
+}
+
+function ensureTrailingNewline(value) {
+  const normalized = normalizeLineEnding(value);
+  return normalized.endsWith("\n") ? normalized : `${normalized}\n`;
+}
+
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error || "unknown error");
+}
+
+module.exports = {
+  ensureDurableNoteSections,
+  inspectDurableNoteRouting,
+  loadDurableNoteSchemaConfig,
+  resolveDurableNoteProfile,
+  resolveDurableNoteRoute,
+};

package/src/core/instructions-template.js

@@ -0,0 +1,31 @@
+function resolveUserPronoun(gender) {
+  const normalized = String(gender || "").trim().toLowerCase();
+  if (normalized === "male" || normalized === "man" || normalized === "m" || normalized === "男") {
+    return "他";
+  }
+  if (normalized === "neutral" || normalized === "nonbinary" || normalized === "nb" || normalized === "ta") {
+    return "TA";
+  }
+  return "她";
+}
+
+function renderInstructionTemplate(template, config = {}) {
+  const userName = String(config?.userName || "").trim() || "用户";
+  const pronoun = resolveUserPronoun(config?.userGender);
+  const codekseiHome = String(
+    config?.codekseiHome
+    || config?.cyberbossHome
+    || process.env.CODEKSEI_HOME
+    || process.env.CYBERBOSS_HOME
+    || ""
+  ).trim();
+  return String(template || "")
+    .replaceAll("{{USER_NAME}}", userName)
+    .replaceAll("{{CYBERBOSS_HOME}}", codekseiHome)
+    .replaceAll("她", pronoun);
+}
+
+module.exports = {
+  renderInstructionTemplate,
+  resolveUserPronoun,
+};