@praeviso/code-env-switch 0.1.0 → 0.1.2

package/src/profile/resolve.ts

@@ -0,0 +1,84 @@
+/**
+ * Profile resolution utilities
+ */
+import type { Config, ProfileType } from "../types";
+import { normalizeType } from "./type";
+import { profileMatchesType, findProfileKeysByName } from "./match";
+
+export function generateProfileKey(config: Config): string {
+    const profiles = config && config.profiles ? config.profiles : {};
+    for (let i = 0; i < 10; i++) {
+        const key = `p_${Date.now().toString(36)}_${Math.random()
+            .toString(36)
+            .slice(2, 8)}`;
+        if (!profiles[key]) return key;
+    }
+    let idx = 0;
+    while (true) {
+        const key = `p_${Date.now().toString(36)}_${idx}`;
+        if (!profiles[key]) return key;
+        idx++;
+    }
+}
+
+export function resolveProfileName(config: Config, params: string[]): string {
+    if (!params || params.length === 0) {
+        throw new Error("Missing profile name.");
+    }
+    if (params.length >= 2) {
+        const maybeType = normalizeType(params[0]);
+        if (maybeType) {
+            const name = params[1];
+            return resolveProfileByType(config, maybeType, name, params[0]);
+        }
+    }
+    const name = params[0];
+    const profiles = config && config.profiles ? config.profiles : {};
+    if (profiles[name]) return name;
+    const matches = findProfileKeysByName(config, name, null);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+        throw new Error(
+            `Multiple profiles named "${name}". ` +
+            `Use: codenv <type> ${name} (or profile key: ${matches.join(", ")})`
+        );
+    }
+    return name;
+}
+
+export function resolveProfileByType(
+    config: Config,
+    type: ProfileType,
+    name: string,
+    rawType: string
+): string {
+    if (!name) throw new Error("Missing profile name.");
+    const profiles = config && config.profiles ? config.profiles : {};
+
+    if (profiles[name] && profileMatchesType(profiles[name], type)) {
+        return name;
+    }
+    const matches = findProfileKeysByName(config, name, type);
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+        throw new Error(
+            `Multiple profiles named "${name}" for type "${type}". ` +
+            `Use profile key: ${matches.join(", ")}`
+        );
+    }
+    if (rawType) {
+        const prefixes: string[] = [];
+        const raw = String(rawType).trim();
+        if (raw && raw.toLowerCase() !== type) prefixes.push(raw);
+        prefixes.push(type);
+        for (const prefix of prefixes) {
+            for (const sep of ["-", "_", "."]) {
+                const candidate = `${prefix}${sep}${name}`;
+                if (profiles[candidate] && profileMatchesType(profiles[candidate], type)) {
+                    return candidate;
+                }
+            }
+        }
+    }
+    throw new Error(`Unknown profile for type "${type}": ${name}`);
+}

package/src/profile/type.ts

@@ -0,0 +1,83 @@
+/**
+ * Profile type handling
+ */
+import type { Profile, ProfileType } from "../types";
+
+export function normalizeType(value: string | null | undefined): ProfileType | null {
+    if (!value) return null;
+    const raw = String(value).trim().toLowerCase();
+    if (!raw) return null;
+    const compact = raw.replace(/[\s_-]+/g, "");
+    if (compact === "codex") return "codex";
+    if (compact === "claude" || compact === "claudecode" || compact === "cc") {
+        return "claude";
+    }
+    return null;
+}
+
+export function hasTypePrefix(name: string, type: ProfileType): boolean {
+    if (!name) return false;
+    const lowered = String(name).toLowerCase();
+    const prefixes = type === "claude" ? [type, "cc"] : [type];
+    for (const prefix of prefixes) {
+        for (const sep of ["-", "_", "."]) {
+            if (lowered.startsWith(`${prefix}${sep}`)) return true;
+        }
+    }
+    return false;
+}
+
+export function hasEnvKeyPrefix(profile: Profile | undefined, prefix: string): boolean {
+    if (!profile || !profile.env) return false;
+    const normalized = prefix.toUpperCase();
+    for (const key of Object.keys(profile.env)) {
+        if (key.toUpperCase().startsWith(normalized)) return true;
+    }
+    return false;
+}
+
+export function inferProfileType(
+    profileName: string,
+    profile: Profile | undefined,
+    requestedType: ProfileType | null
+): ProfileType | null {
+    if (requestedType) return requestedType;
+    const fromProfile = profile ? normalizeType(profile.type) : null;
+    if (fromProfile) return fromProfile;
+    if (hasEnvKeyPrefix(profile, "OPENAI_")) return "codex";
+    if (hasEnvKeyPrefix(profile, "ANTHROPIC_")) return "claude";
+    if (hasTypePrefix(profileName, "codex")) return "codex";
+    if (hasTypePrefix(profileName, "claude")) return "claude";
+    return null;
+}
+
+export function stripTypePrefixFromName(name: string, type: string): string {
+    if (!name) return name;
+    const normalizedType = normalizeType(type);
+    if (!normalizedType) return name;
+    const lowered = String(name).toLowerCase();
+    const prefixes = normalizedType === "claude" ? [normalizedType, "cc"] : [normalizedType];
+    for (const prefix of prefixes) {
+        for (const sep of ["-", "_", "."]) {
+            const candidate = `${prefix}${sep}`;
+            if (lowered.startsWith(candidate)) {
+                const stripped = String(name).slice(candidate.length);
+                return stripped || name;
+            }
+        }
+    }
+    return name;
+}
+
+export function getProfileDisplayName(
+    profileKey: string,
+    profile: Profile,
+    requestedType?: string | null
+): string {
+    if (profile.name) return String(profile.name);
+    const rawType = profile.type ? String(profile.type) : "";
+    if (rawType) return stripTypePrefixFromName(profileKey, rawType);
+    if (requestedType) return stripTypePrefixFromName(profileKey, requestedType);
+    return profileKey;
+}
+

package/src/shell/detect.ts

@@ -0,0 +1,30 @@
+/**
+ * Shell detection utilities
+ */
+import * as path from "path";
+import * as os from "os";
+
+export function normalizeShell(value: string | null | undefined): string | null {
+    if (!value) return null;
+    const raw = String(value).trim().toLowerCase();
+    if (!raw) return null;
+    if (raw === "bash") return "bash";
+    if (raw === "zsh") return "zsh";
+    if (raw === "fish") return "fish";
+    return null;
+}
+
+export function detectShell(explicitShell: string | null | undefined): string | null {
+    if (explicitShell) return normalizeShell(explicitShell);
+    const envShell = process.env.SHELL ? path.basename(process.env.SHELL) : "";
+    return normalizeShell(envShell);
+}
+
+export function getShellRcPath(shellName: string | null): string | null {
+    if (shellName === "bash") return path.join(os.homedir(), ".bashrc");
+    if (shellName === "zsh") return path.join(os.homedir(), ".zshrc");
+    if (shellName === "fish") {
+        return path.join(os.homedir(), ".config", "fish", "config.fish");
+    }
+    return null;
+}

package/src/shell/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Shell module exports
+ */
+export { normalizeShell, detectShell, getShellRcPath } from "./detect";
+export { getShellSnippet, escapeRegExp, upsertShellSnippet } from "./snippet";
+export { shellEscape, expandEnv, resolvePath } from "./utils";

package/src/shell/snippet.ts

@@ -0,0 +1,92 @@
+/**
+ * Shell snippet generation
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+export function getShellSnippet(shellName: string | null): string {
+    if (shellName === "fish") {
+        return [
+            "if not set -q CODE_ENV_TERMINAL_TAG",
+            "  if type -q uuidgen",
+            "    set -gx CODE_ENV_TERMINAL_TAG (uuidgen)",
+            "  else",
+            "    set -gx CODE_ENV_TERMINAL_TAG (date +%s)-$fish_pid-(random)",
+            "  end",
+            "end",
+            "function codenv",
+            "  if test (count $argv) -ge 1",
+            "    switch $argv[1]",
+            "      case use unset auto",
+            "        command codenv $argv | source",
+            "      case '*'",
+            "        command codenv $argv",
+            "    end",
+            "  else",
+            "    command codenv",
+            "  end",
+            "end",
+            "function codex",
+            "  command codenv launch codex -- $argv",
+            "end",
+            "function claude",
+            "  command codenv launch claude -- $argv",
+            "end",
+            "codenv auto",
+        ].join("\n");
+    }
+    return [
+        'if [ -z "$CODE_ENV_TERMINAL_TAG" ]; then',
+        '  if command -v uuidgen >/dev/null 2>&1; then',
+        '    CODE_ENV_TERMINAL_TAG="$(uuidgen)"',
+        "  else",
+        '    CODE_ENV_TERMINAL_TAG="$(date +%s)-$$-$RANDOM"',
+        "  fi",
+        "  export CODE_ENV_TERMINAL_TAG",
+        "fi",
+        "codenv() {",
+        '  if [ "$1" = "use" ] || [ "$1" = "unset" ] || [ "$1" = "auto" ]; then',
+        '    source <(command codenv "$@")',
+        "  else",
+        '    command codenv "$@"',
+        "  fi",
+        "}",
+        "codex() {",
+        '  command codenv launch codex -- "$@"',
+        "}",
+        "claude() {",
+        '  command codenv launch claude -- "$@"',
+        "}",
+        "codenv auto",
+    ].join("\n");
+}
+
+export function escapeRegExp(value: string): string {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function upsertShellSnippet(rcPath: string, snippet: string): void {
+    const markerStart = "# >>> codenv >>>";
+    const markerEnd = "# <<< codenv <<<";
+    const block = `${markerStart}\n${snippet}\n${markerEnd}`;
+    const existing = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, "utf8") : "";
+    let updated = "";
+
+    if (existing.includes(markerStart) && existing.includes(markerEnd)) {
+        const re = new RegExp(
+            `${escapeRegExp(markerStart)}[\\s\\S]*?${escapeRegExp(markerEnd)}`
+        );
+        updated = existing.replace(re, block);
+    } else if (existing.trim().length === 0) {
+        updated = `${block}\n`;
+    } else {
+        const sep = existing.endsWith("\n") ? "\n" : "\n\n";
+        updated = `${existing}${sep}${block}\n`;
+    }
+
+    const dir = path.dirname(rcPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(rcPath, updated, "utf8");
+}

package/src/shell/utils.ts

@@ -0,0 +1,30 @@
+/**
+ * Shell utility functions
+ */
+import * as path from "path";
+import * as os from "os";
+
+export function shellEscape(value: string | number | boolean): string {
+    const str = String(value);
+    return `'${str.replace(/'/g, `'\\''`)}'`;
+}
+
+export function expandEnv(input: string | null | undefined): string | null | undefined {
+    if (!input) return input;
+    let out = String(input);
+    if (out.startsWith("~")) {
+        out = path.join(os.homedir(), out.slice(1));
+    }
+    out = out.replace(/\$\{([^}]+)\}/g, (_, key) => process.env[key] || "");
+    out = out.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (_, key) => process.env[key] || "");
+    return out;
+}
+
+export function resolvePath(p: string | null | undefined): string | null {
+    if (!p) return null;
+    if (p.startsWith("~")) {
+        return path.join(os.homedir(), p.slice(1));
+    }
+    if (path.isAbsolute(p)) return p;
+    return path.resolve(process.cwd(), p);
+}

package/src/statusline/claude.ts

@@ -0,0 +1,172 @@
+/**
+ * Claude Code statusline integration
+ */
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import type { Config } from "../types";
+import { expandEnv, resolvePath } from "../shell/utils";
+import { askConfirm, createReadline } from "../ui";
+
+const DEFAULT_CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const DEFAULT_STATUSLINE_COMMAND = "codenv statusline --type claude --sync-usage";
+const DEFAULT_STATUSLINE_TYPE = "command";
+const DEFAULT_STATUSLINE_PADDING = 0;
+
+interface DesiredStatusLineConfig {
+    type: string;
+    command: string;
+    padding: number;
+    settingsPath: string;
+}
+
+function parseBooleanEnv(value: string | undefined): boolean | null {
+    if (value === undefined) return null;
+    const normalized = String(value).trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) return true;
+    if (["0", "false", "no", "off"].includes(normalized)) return false;
+    return null;
+}
+
+function resolveClaudeSettingsPath(config: Config): string {
+    const override = process.env.CODE_ENV_CLAUDE_SETTINGS_PATH;
+    if (override && String(override).trim()) {
+        const expanded = expandEnv(String(override).trim());
+        return resolvePath(expanded) || DEFAULT_CLAUDE_SETTINGS_PATH;
+    }
+    const configOverride = config.claudeStatusline?.settingsPath;
+    if (configOverride && String(configOverride).trim()) {
+        const expanded = expandEnv(String(configOverride).trim());
+        return resolvePath(expanded) || DEFAULT_CLAUDE_SETTINGS_PATH;
+    }
+    return DEFAULT_CLAUDE_SETTINGS_PATH;
+}
+
+function readSettings(filePath: string): Record<string, unknown> | null {
+    if (!fs.existsSync(filePath)) return {};
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const trimmed = raw.trim();
+        if (!trimmed) return {};
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed as Record<string, unknown>;
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isCommandStatusLine(
+    value: unknown
+): value is { type: string; command: string; padding?: number } {
+    if (!isPlainObject(value)) return false;
+    const type = value.type;
+    const command = value.command;
+    return typeof type === "string" && typeof command === "string";
+}
+
+function resolveCommand(command: string | string[] | undefined): string {
+    if (typeof command === "string") {
+        const trimmed = command.trim();
+        if (trimmed) return trimmed;
+    }
+    if (Array.isArray(command)) {
+        const cleaned = command
+            .map((entry) => String(entry).trim())
+            .filter((entry) => entry);
+        if (cleaned.length > 0) return cleaned.join(" ");
+    }
+    return DEFAULT_STATUSLINE_COMMAND;
+}
+
+function resolveDesiredStatusLineConfig(config: Config): DesiredStatusLineConfig {
+    const type = config.claudeStatusline?.type || DEFAULT_STATUSLINE_TYPE;
+    const command = resolveCommand(config.claudeStatusline?.command);
+    const paddingRaw = config.claudeStatusline?.padding;
+    const padding =
+        typeof paddingRaw === "number" && Number.isFinite(paddingRaw)
+            ? Math.floor(paddingRaw)
+            : DEFAULT_STATUSLINE_PADDING;
+    const settingsPath = resolveClaudeSettingsPath(config);
+    return { type, command, padding, settingsPath };
+}
+
+function statusLineMatches(
+    existing: unknown,
+    desired: DesiredStatusLineConfig
+): boolean {
+    if (!isCommandStatusLine(existing)) return false;
+    if (existing.type !== desired.type) return false;
+    if (existing.command !== desired.command) return false;
+    const existingPadding =
+        typeof existing.padding === "number" ? existing.padding : undefined;
+    if (existingPadding !== desired.padding) return false;
+    return true;
+}
+
+export async function ensureClaudeStatusline(
+    config: Config,
+    enabled: boolean
+): Promise<boolean> {
+    const disabled =
+        parseBooleanEnv(process.env.CODE_ENV_CLAUDE_STATUSLINE_DISABLE) === true;
+    if (!enabled || disabled) return false;
+    const desired = resolveDesiredStatusLineConfig(config);
+    const settingsPath = desired.settingsPath;
+    const force =
+        parseBooleanEnv(process.env.CODE_ENV_CLAUDE_STATUSLINE_FORCE) === true;
+
+    const settings = readSettings(settingsPath);
+    if (!settings) {
+        console.error(
+            "codenv: unable to read Claude settings; skipping statusLine update."
+        );
+        return false;
+    }
+
+    const existing = settings.statusLine;
+    if (existing && statusLineMatches(existing, desired)) {
+        return false;
+    }
+
+    if (typeof existing !== "undefined" && !force) {
+        console.log(`codenv: existing Claude statusLine config in ${settingsPath}:`);
+        console.log(JSON.stringify(existing, null, 2));
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.warn("codenv: no TTY available to confirm statusLine overwrite.");
+            return false;
+        }
+        const rl = createReadline();
+        try {
+            const confirm = await askConfirm(
+                rl,
+                "Overwrite Claude statusLine config? (y/N): "
+            );
+            if (!confirm) return false;
+        } finally {
+            rl.close();
+        }
+    }
+
+    settings.statusLine = {
+        type: desired.type,
+        command: desired.command,
+        padding: desired.padding,
+    };
+    try {
+        fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+        fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+        return true;
+    } catch {
+        console.error(
+            "codenv: failed to write Claude settings; statusLine not updated."
+        );
+        return false;
+    }
+}