@golba98/codexa 1.0.1

package/src/config/settings.ts

@@ -0,0 +1,401 @@
+import { homedir } from "os";
+import { basename, join, parse, win32 } from "path";
+
+function isWindowsStylePath(p: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(p) || /^\\\\/.test(p);
+}
+
+function smartJoin(base: string, ...parts: string[]): string {
+  return isWindowsStylePath(base) ? win32.join(base, ...parts) : join(base, ...parts);
+}
+
+export const APP_NAME = "Codexa";
+export const APP_VERSION = "1.0.1";
+export const DEFAULT_BACKEND = "codex-subprocess";
+export const DEFAULT_MODEL = "gpt-5.4";
+export const DEFAULT_MODE = "full-auto";
+export const DEFAULT_REASONING_LEVEL = "high";
+export const DEFAULT_LAYOUT_STYLE = "gemini-shell";
+export const DEFAULT_THEME = "mono";
+export const DEFAULT_WORKSPACE_DISPLAY_MODE = "dir";
+export const DEFAULT_TERMINAL_TITLE_MODE = "dir";
+export const DEFAULT_SHOW_BUSY_LOADER = true;
+export const DEFAULT_AUTH_PREFERENCE = "chatgpt-login-goal";
+export const CODEX_EXECUTABLE = process.env.CODEX_EXECUTABLE || "codex";
+export const CLAUDE_EXECUTABLE = process.env.CLAUDE_EXECUTABLE || null;
+export const MAX_CHAT_LINES = 2000;
+export const MAX_VISIBLE_EVENTS = 8;
+
+export function getCodexHome(): string {
+  return process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+}
+
+export function getCodexConfigFile(): string {
+  return smartJoin(getCodexHome(), "config.toml");
+}
+
+export function getCodexaTrustStoreFile(): string {
+  return smartJoin(getCodexHome(), "codexa-trust.json");
+}
+
+export const CODEX_HOME = getCodexHome();
+export const CODEX_CONFIG_FILE = getCodexConfigFile();
+export const CODEXA_TRUST_STORE_FILE = getCodexaTrustStoreFile();
+export const SETTINGS_FILE = join(homedir(), ".codexa-settings.json");
+export const MODEL_SPECS_FILE = join(homedir(), ".codexa-model-specs.json");
+
+export const AVAILABLE_BACKENDS = [
+  {
+    id: "codex-subprocess",
+    label: "Codexa Core",
+    description: "Direct connection to the Codexa neural network.",
+  },
+  {
+    id: "openai-native",
+    label: "OpenAI Native",
+    description: "Future native provider. ChatGPT subscriptions do not automatically grant API access.",
+  },
+] as const;
+
+export type AvailableBackend = (typeof AVAILABLE_BACKENDS)[number]["id"];
+
+// Static model list used when runtime model discovery is unavailable.
+// Named "legacy fallback" because dynamic discovery is the preferred source of truth,
+// but this list is the live exported AVAILABLE_MODELS for now.
+export const LEGACY_FALLBACK_MODELS = [
+  "gpt-5.5",
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "gpt-5.3-codex",
+  "gpt-5.2",
+] as const;
+
+export const AVAILABLE_MODELS = LEGACY_FALLBACK_MODELS;
+
+export type AvailableModel = string;
+
+export const AVAILABLE_REASONING_LEVELS = [
+  { id: "none", label: "None" },
+  { id: "minimal", label: "Minimal" },
+  { id: "low", label: "Low" },
+  { id: "medium", label: "Medium" },
+  { id: "high", label: "High" },
+  { id: "xhigh", label: "XHigh" },
+  { id: "max", label: "Max" },
+] as const;
+
+export type ReasoningLevel = string;
+
+export const WORKSPACE_DISPLAY_MODES = ["dir", "name", "simple"] as const;
+export const LEGACY_DIRECTORY_DISPLAY_MODES = ["normal", "simple"] as const;
+
+export type WorkspaceDisplayMode = (typeof WORKSPACE_DISPLAY_MODES)[number];
+export type LegacyDirectoryDisplayMode = (typeof LEGACY_DIRECTORY_DISPLAY_MODES)[number];
+export type TerminalTitleMode = WorkspaceDisplayMode;
+
+export const BUSY_LOADER_SETTING_VALUES = ["true", "false"] as const;
+
+export type BusyLoaderSettingValue = (typeof BUSY_LOADER_SETTING_VALUES)[number];
+
+export const TERMINAL_MOUSE_MODES = ["wheel", "selection"] as const;
+
+export type TerminalMouseMode = (typeof TERMINAL_MOUSE_MODES)[number];
+
+export const DEFAULT_TERMINAL_MOUSE_MODE: TerminalMouseMode = "selection";
+
+export interface SettingOption<TValue extends string> {
+  value: TValue;
+  label: string;
+}
+
+export interface SettingDefinition<TKey extends string, TValue extends string> {
+  key: TKey;
+  label: string;
+  description?: string;
+  options: readonly SettingOption<TValue>[];
+}
+
+export interface UserSettingValues {
+  workspaceDisplayMode: WorkspaceDisplayMode;
+  terminalTitleMode: TerminalTitleMode;
+  showBusyLoader: BusyLoaderSettingValue;
+  terminalMouseMode: TerminalMouseMode;
+}
+
+export type UserSettingKey = keyof UserSettingValues;
+
+export type UserSettingDefinition = {
+  [K in UserSettingKey]: SettingDefinition<K, UserSettingValues[K]>;
+}[UserSettingKey];
+
+export const USER_SETTING_DEFINITIONS: readonly UserSettingDefinition[] = [
+  {
+    key: "workspaceDisplayMode",
+    label: "Workspace display",
+    description: "Controls how the workspace label is displayed in the Codexa header.",
+    options: [
+      { value: "dir", label: "Dir" },
+      { value: "name", label: "Name" },
+      { value: "simple", label: "Simple" },
+    ],
+  },
+  {
+    key: "terminalTitleMode",
+    label: "Terminal title",
+    description: "Controls how the terminal tab/window title is displayed.",
+    options: [
+      { value: "dir", label: "Dir" },
+      { value: "name", label: "Name" },
+      { value: "simple", label: "Simple" },
+    ],
+  },
+  {
+    key: "showBusyLoader",
+    label: "Busy loader",
+    description: "Controls whether the footer shows a subtle loading animation while Codexa is busy.",
+    options: [
+      { value: "true", label: "True" },
+      { value: "false", label: "False" },
+    ],
+  },
+  {
+    key: "terminalMouseMode",
+    label: "Mouse mode",
+    description:
+      "Selection (default): no mouse tracking — native drag-select and native wheel scroll work unmodified. "
+      + "Scroll history via native terminal scrollback. "
+      + "Wheel: enables SGR mouse tracking so the Codexa timeline captures wheel events for in-app scroll. "
+      + "Native drag-select then requires Shift (Windows Terminal) or equivalent modifier. "
+      + "Run /mouse to toggle for the current session.",
+    options: [
+      { value: "selection", label: "Native selection" },
+      { value: "wheel", label: "Wheel scroll" },
+    ],
+  },
+] as const;
+
+/** Rough token estimate: ~4 chars per token */
+export function estimateTokens(chars: number): number {
+  return Math.ceil(chars / 4);
+}
+
+export const AVAILABLE_MODES = [
+  { key: "suggest", label: "Read-only" },
+  { key: "auto-edit", label: "Auto" },
+  { key: "full-auto", label: "Full Access" },
+] as const;
+
+export type AvailableMode = (typeof AVAILABLE_MODES)[number]["key"];
+
+export const MODE_COMMAND_ALIASES = {
+  default: DEFAULT_MODE,
+  ask: "suggest",
+  add: "auto-edit",
+  auto: "auto-edit",
+  plan: "suggest",
+} as const;
+
+export type ModeCommandAlias = keyof typeof MODE_COMMAND_ALIASES;
+
+export const AUTH_PREFERENCES = [
+  {
+    id: "chatgpt-login-goal",
+    label: "ChatGPT login goal",
+    description: "Design toward account-style sign-in without claiming it works as a backend today.",
+  },
+  {
+    id: "api-key-first",
+    label: "API key first",
+    description: "Prefer official API credentials when native OpenAI support is added.",
+  },
+  {
+    id: "runner-managed",
+    label: "Codexa managed",
+    description: "Rely on the core neural bridge to manage authentication.",
+  },
+] as const;
+
+export type AuthPreference = (typeof AUTH_PREFERENCES)[number]["id"];
+
+export function formatModeLabel(mode: string): string {
+  const found = AVAILABLE_MODES.find((m) => m.key === mode);
+  return found?.label ?? mode.toUpperCase();
+}
+
+export function resolveModeCommand(mode: string): AvailableMode | null {
+  const normalized = mode.toLowerCase();
+  const canonical = AVAILABLE_MODES.find((item) => item.key === normalized);
+  if (canonical) {
+    return canonical.key;
+  }
+
+  return MODE_COMMAND_ALIASES[normalized as ModeCommandAlias] ?? null;
+}
+
+export function formatModeCommandHelp(): string {
+  return "suggest, auto-edit, full-auto; aliases: default, ask, add, auto, plan";
+}
+
+export function getNextMode(mode: AvailableMode): AvailableMode {
+  const currentIndex = AVAILABLE_MODES.findIndex((item) => item.key === mode);
+  if (currentIndex < 0) {
+    return AVAILABLE_MODES[0].key;
+  }
+
+  return AVAILABLE_MODES[(currentIndex + 1) % AVAILABLE_MODES.length].key;
+}
+
+export function formatBackendLabel(backend: string): string {
+  const found = AVAILABLE_BACKENDS.find((item) => item.id === backend);
+  return found?.label ?? backend;
+}
+
+export function formatReasoningLabel(reasoning: string): string {
+  const found = AVAILABLE_REASONING_LEVELS.find((item) => item.id === reasoning);
+  if (found) {
+    return found.label;
+  }
+
+  return reasoning
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+    .join(" ") || reasoning;
+}
+
+export const AVAILABLE_THEMES = [
+  { id: "purple", label: "Midnight Purple" },
+  { id: "mono", label: "Black & White" },
+  { id: "dark", label: "Modern Dark" },
+  { id: "black", label: "Codex the Black" },
+  { id: "emerald", label: "Emerald Night" },
+  { id: "solar", label: "Solar Flare" },
+  { id: "cyber", label: "Cyberpunk Neon" },
+  { id: "ocean", label: "Deep Oceanic" },
+  { id: "nordic", label: "Nordic Frost" },
+  { id: "green", label: "Terminal Green" },
+  { id: "amber", label: "Terminal Amber" },
+  { id: "vaporwave", label: "Vaporwave Dream" },
+  { id: "dracula", label: "Dracula Night" },
+  { id: "gruvbox", label: "Gruvbox Hard" },
+  { id: "synthwave", label: "Synthwave '84" },
+  { id: "custom", label: "Customize..." },
+] as const;
+
+export type AvailableTheme = (typeof AVAILABLE_THEMES)[number]["id"];
+
+export function formatThemeLabel(themeId: string): string {
+  const found = AVAILABLE_THEMES.find((item) => item.id === themeId);
+  return found?.label ?? themeId;
+}
+
+export function formatWorkspaceDisplayModeLabel(mode: WorkspaceDisplayMode): string {
+  if (mode === "name") return "Name";
+  if (mode === "simple") return "Simple";
+  return "Dir";
+}
+
+export function formatTerminalTitleModeLabel(mode: TerminalTitleMode): string {
+  return formatWorkspaceDisplayModeLabel(mode);
+}
+
+// Maps the old "normal" value (pre-rename) to the current "dir" equivalent.
+export function normalizeLegacyDirectoryDisplayMode(mode: LegacyDirectoryDisplayMode): WorkspaceDisplayMode {
+  return mode === "simple" ? "simple" : "dir";
+}
+
+export function formatDirectoryDisplayModeLabel(mode: WorkspaceDisplayMode | LegacyDirectoryDisplayMode): string {
+  if (mode === "normal") return "Dir";
+  return formatWorkspaceDisplayModeLabel(mode);
+}
+
+export function formatBusyLoaderSettingValue(enabled: boolean): BusyLoaderSettingValue {
+  return enabled ? "true" : "false";
+}
+
+export function parseBusyLoaderSettingValue(value: string): boolean {
+  return value === "true";
+}
+
+function formatWorkspaceLeaf(workspaceRoot: string): string {
+  const trimmed = workspaceRoot.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+
+  const api = isWindowsStylePath(trimmed) ? win32 : { parse, basename };
+  const { root } = api.parse(trimmed);
+  let normalized = trimmed;
+  // Stop at filesystem root — root.length > 0 prevents stripping the root itself
+  while (normalized.length > root.length && /[\\/]+$/.test(normalized)) {
+    normalized = normalized.slice(0, -1);
+  }
+
+  if (!normalized) {
+    return trimmed;
+  }
+
+  if (normalized === root) {
+    return root || trimmed;
+  }
+
+  return api.basename(normalized) || normalized;
+}
+
+export function formatWorkspaceDisplayPath(
+  workspaceRoot: string,
+  workspaceDisplayMode: WorkspaceDisplayMode,
+): string {
+  if (workspaceDisplayMode === "name") {
+    return APP_NAME;
+  }
+
+  return formatWorkspaceLeaf(workspaceRoot);
+}
+
+export function formatTerminalTitlePath(
+  workspaceRoot: string,
+  terminalTitleMode: TerminalTitleMode,
+): string {
+  if (terminalTitleMode === "name" || terminalTitleMode === "simple") {
+    return APP_NAME;
+  }
+
+  return formatWorkspaceLeaf(workspaceRoot);
+}
+
+export interface HeaderConfig {
+  showBrand: boolean;
+  showWorkspace: boolean;
+  showProvider: boolean;
+  showModel: boolean;
+  showReasoning: boolean;
+  showContext: boolean;
+  showAuthStatus: boolean;
+}
+
+export const HEADER_CONFIG_DEFAULTS: HeaderConfig = {
+  showBrand: true,
+  showWorkspace: true,
+  showProvider: false,
+  showModel: false,
+  showReasoning: false,
+  showContext: false,
+  showAuthStatus: false,
+};
+
+export function getRecommendedReasoningForModel(model: AvailableModel): ReasoningLevel {
+  return DEFAULT_REASONING_LEVEL;
+}
+
+export function normalizeReasoningForModel(
+  model: AvailableModel,
+  reasoningLevel: ReasoningLevel,
+): ReasoningLevel {
+  return reasoningLevel || getRecommendedReasoningForModel(model);
+}
+
+export function formatAuthPreferenceLabel(preference: string): string {
+  const found = AUTH_PREFERENCES.find((item) => item.id === preference);
+  return found?.label ?? preference;
+}

package/src/config/toml-serialize.ts

@@ -0,0 +1,98 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isPrimitive(value: unknown): value is string | number | boolean {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function formatTomlPrimitive(value: string | number | boolean): string {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return `${value}`;
+}
+
+function formatTomlArray(values: readonly unknown[]): string {
+  return `[${values.map((value) => {
+    if (isPrimitive(value)) {
+      return formatTomlPrimitive(value);
+    }
+
+    if (Array.isArray(value)) {
+      return formatTomlArray(value);
+    }
+
+    if (isRecord(value)) {
+      return `{ ${Object.entries(value).map(([key, item]) => `${key} = ${formatTomlValue(item)}`).join(", ")} }`;
+    }
+
+    // TOML has no null literal; fall back to JSON encoding for unknown types.
+    return JSON.stringify(value ?? null);
+  }).join(", ")}]`;
+}
+
+function formatTomlValue(value: unknown): string {
+  if (isPrimitive(value)) {
+    return formatTomlPrimitive(value);
+  }
+
+  if (Array.isArray(value)) {
+    return formatTomlArray(value);
+  }
+
+  if (isRecord(value)) {
+    return `{ ${Object.entries(value).map(([key, item]) => `${key} = ${formatTomlValue(item)}`).join(", ")} }`;
+  }
+
+  // TOML has no null literal; fall back to JSON encoding for unknown types.
+  return JSON.stringify(value ?? null);
+}
+
+function serializeTomlSection(
+  path: readonly string[],
+  value: Record<string, unknown>,
+  lines: string[],
+): void {
+  const scalarEntries = Object.entries(value).filter(([, item]) => !isRecord(item) && !Array.isArray(item));
+  const arrayEntries = Object.entries(value).filter(([, item]) => Array.isArray(item) && !(item as unknown[]).every(isRecord));
+  const tableEntries = Object.entries(value).filter(([, item]) => isRecord(item));
+  // An array whose every element is a record is a TOML array-of-tables ([[key]]).
+  const arrayTableEntries = Object.entries(value).filter(([, item]) => Array.isArray(item) && (item as unknown[]).every(isRecord));
+
+  if (path.length > 0) {
+    lines.push(`[${path.join(".")}]`);
+  }
+
+  for (const [key, item] of [...scalarEntries, ...arrayEntries]) {
+    lines.push(`${key} = ${formatTomlValue(item)}`);
+  }
+
+  for (const [key, item] of tableEntries) {
+    if (lines.length > 0 && lines[lines.length - 1] !== "") {
+      lines.push("");
+    }
+    serializeTomlSection([...path, key], item as Record<string, unknown>, lines);
+  }
+
+  for (const [key, item] of arrayTableEntries) {
+    for (const table of item as Record<string, unknown>[]) {
+      if (lines.length > 0 && lines[lines.length - 1] !== "") {
+        lines.push("");
+      }
+      lines.push(`[[${[...path, key].join(".")}]]`);
+      const tableLines: string[] = [];
+      serializeTomlSection([], table, tableLines);
+      lines.push(...tableLines);
+    }
+  }
+}
+
+export function serializeTomlDocument(data: Record<string, unknown>): string {
+  const lines: string[] = [];
+  serializeTomlSection([], data, lines);
+  return `${lines.join("\n").trim()}\n`;
+}

package/src/config/trustStore.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import test from "node:test";
+
+test("persists trusted project roots", async () => {
+  const tempHome = mkdtempSync(join(tmpdir(), "codexa-trust-store-"));
+  const previousCodexHome = process.env.CODEX_HOME;
+  process.env.CODEX_HOME = tempHome;
+
+  try {
+    const module = await import(`./trustStore.js?trust=${Date.now()}`);
+    const projectRoot = "C:/Workspace/Repo";
+
+    assert.equal(module.isProjectTrusted(projectRoot), false);
+    module.setProjectTrust(projectRoot, true);
+    assert.equal(module.isProjectTrusted(projectRoot), true);
+    module.setProjectTrust(projectRoot, false);
+    assert.equal(module.isProjectTrusted(projectRoot), false);
+  } finally {
+    if (previousCodexHome === undefined) {
+      delete process.env.CODEX_HOME;
+    } else {
+      process.env.CODEX_HOME = previousCodexHome;
+    }
+    rmSync(tempHome, { recursive: true, force: true });
+  }
+});

package/src/config/trustStore.ts

@@ -0,0 +1,68 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { getCodexaTrustStoreFile } from "./settings.js";
+import { normalizeWorkspaceRoot } from "../core/workspaceRoot.js";
+
+interface TrustStoreData {
+  trustedProjectRoots: string[];
+}
+
+function getDefaultTrustStore(): TrustStoreData {
+  return { trustedProjectRoots: [] };
+}
+
+function parseTrustStoreData(data: unknown): TrustStoreData {
+  if (!data || typeof data !== "object") {
+    return getDefaultTrustStore();
+  }
+
+  const record = data as Record<string, unknown>;
+  const trustedProjectRoots = Array.isArray(record.trustedProjectRoots)
+    ? record.trustedProjectRoots
+      .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+      .map((value) => normalizeWorkspaceRoot(value))
+    : [];
+
+  return {
+    trustedProjectRoots: Array.from(new Set(trustedProjectRoots)),
+  };
+}
+
+function loadTrustStore(): TrustStoreData {
+  try {
+    const trustStoreFile = getCodexaTrustStoreFile();
+    const text = readFileSync(trustStoreFile, "utf-8");
+    return parseTrustStoreData(JSON.parse(text));
+  } catch {
+    // Best-effort persistence; corrupt or missing file silently resets to empty.
+    return getDefaultTrustStore();
+  }
+}
+
+function saveTrustStore(data: TrustStoreData): void {
+  try {
+    const trustStoreFile = getCodexaTrustStoreFile();
+    mkdirSync(dirname(trustStoreFile), { recursive: true });
+    const tmpFile = `${trustStoreFile}.tmp`;
+    writeFileSync(tmpFile, JSON.stringify(data, null, 2), "utf-8");
+    renameSync(tmpFile, trustStoreFile);
+  } catch {
+    // Best-effort persistence only.
+  }
+}
+
+export function isProjectTrusted(projectRoot: string): boolean {
+  const normalizedRoot = normalizeWorkspaceRoot(projectRoot);
+  const store = loadTrustStore();
+  return store.trustedProjectRoots.includes(normalizedRoot);
+}
+
+export function setProjectTrust(projectRoot: string, trusted: boolean): void {
+  const normalizedRoot = normalizeWorkspaceRoot(projectRoot);
+  const store = loadTrustStore();
+  const nextRoots = trusted
+    ? Array.from(new Set([...store.trustedProjectRoots, normalizedRoot]))
+    : store.trustedProjectRoots.filter((value) => value !== normalizedRoot);
+
+  saveTrustStore({ trustedProjectRoots: nextRoots });
+}