@praeviso/code-env-switch 0.1.1 → 0.1.3

package/code-env.example.json

@@ -4,6 +4,17 @@
     "codex": "primary",
     "claude": "default"
   },
+  "codexStatusline": {
+    "command": ["codenv", "statusline", "--type", "codex", "--sync-usage"],
+    "showHints": false,
+    "updateIntervalMs": 300,
+    "timeoutMs": 1000
+  },
+  "claudeStatusline": {
+    "command": "codenv statusline --type claude --sync-usage",
+    "type": "command",
+    "padding": 0
+  },
   "profiles": {
     "p_a1b2c3": {
       "name": "primary",

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@praeviso/code-env-switch",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Switch between Claude Code and Codex environment variables from a single CLI",
   "bin": {
-    "codenv": "bin/codenv.js"
+    "codenv": "bin/index.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",

package/src/cli/args.ts

@@ -0,0 +1,318 @@
+/**
+ * CLI argument parsing
+ */
+import type {
+    ParsedArgs,
+    InitArgs,
+    AddArgs,
+    ProfileType,
+    StatuslineArgs,
+} from "../types";
+import { normalizeType } from "../profile/type";
+
+export function parseArgs(argv: string[]): ParsedArgs {
+    let configPath: string | null = null;
+    const args: string[] = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "-h" || arg === "--help") {
+            return { args: [], configPath: null, help: true };
+        }
+        if (arg === "-c" || arg === "--config") {
+            configPath = argv[i + 1];
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            configPath = arg.slice("--config=".length);
+            continue;
+        }
+        args.push(arg);
+    }
+    return { args, configPath, help: false };
+}
+
+export function parseInitArgs(args: string[]): InitArgs {
+    const result: InitArgs = { apply: true, print: false, shell: null };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--apply") {
+            result.apply = true;
+            result.print = false;
+            continue;
+        }
+        if (arg === "--print") {
+            result.print = true;
+            result.apply = false;
+            continue;
+        }
+        if (arg === "--shell") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --shell.");
+            result.shell = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--shell=")) {
+            result.shell = arg.slice("--shell=".length);
+            continue;
+        }
+        throw new Error(`Unknown init argument: ${arg}`);
+    }
+    return result;
+}
+
+export function parseAddArgs(args: string[]): AddArgs {
+    const result: AddArgs = {
+        profile: null,
+        pairs: [],
+        note: null,
+        removeFiles: [],
+        commands: [],
+        unset: [],
+        type: null,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!result.profile && !arg.startsWith("-")) {
+            result.profile = arg;
+            continue;
+        }
+        if (arg === "-n" || arg === "--note") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --note.");
+            result.note = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--note=")) {
+            result.note = arg.slice("--note=".length);
+            continue;
+        }
+        if (arg === "-t" || arg === "--type") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --type.");
+            result.type = val as ProfileType;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--type=")) {
+            result.type = arg.slice("--type=".length) as ProfileType;
+            continue;
+        }
+        if (arg === "-r" || arg === "--remove-file") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --remove-file.");
+            result.removeFiles.push(val);
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--remove-file=")) {
+            result.removeFiles.push(arg.slice("--remove-file=".length));
+            continue;
+        }
+        if (arg === "-x" || arg === "--command") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --command.");
+            result.commands.push(val);
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--command=")) {
+            result.commands.push(arg.slice("--command=".length));
+            continue;
+        }
+        if (arg === "-u" || arg === "--unset") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --unset.");
+            result.unset.push(val);
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--unset=")) {
+            result.unset.push(arg.slice("--unset=".length));
+            continue;
+        }
+        if (arg.includes("=")) {
+            result.pairs.push(arg);
+            continue;
+        }
+        throw new Error(`Unknown add argument: ${arg}`);
+    }
+
+    if (!result.profile) {
+        throw new Error("Missing profile name.");
+    }
+
+    if (result.type) {
+        const normalized = normalizeType(result.type);
+        if (!normalized) {
+            throw new Error(`Unknown type: ${result.type}`);
+        }
+        result.type = normalized;
+    }
+
+    return result;
+}
+
+function parseNumberFlag(value: string | null | undefined, flag: string): number {
+    if (value === null || value === undefined || value === "") {
+        throw new Error(`Missing value for ${flag}.`);
+    }
+    const num = Number(value);
+    if (!Number.isFinite(num)) {
+        throw new Error(`Invalid number for ${flag}: ${value}`);
+    }
+    return num;
+}
+
+export function parseStatuslineArgs(args: string[]): StatuslineArgs {
+    const result: StatuslineArgs = {
+        format: "text",
+        cwd: null,
+        type: null,
+        profileKey: null,
+        profileName: null,
+        model: null,
+        usageToday: null,
+        usageTotal: null,
+        usageInput: null,
+        usageOutput: null,
+        syncUsage: false,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--format") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --format.");
+            const normalized = val.toLowerCase();
+            if (normalized !== "text" && normalized !== "json") {
+                throw new Error(`Unknown format: ${val}`);
+            }
+            result.format = normalized as "text" | "json";
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--format=")) {
+            const val = arg.slice("--format=".length);
+            const normalized = val.toLowerCase();
+            if (normalized !== "text" && normalized !== "json") {
+                throw new Error(`Unknown format: ${val}`);
+            }
+            result.format = normalized as "text" | "json";
+            continue;
+        }
+        if (arg === "--cwd") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --cwd.");
+            result.cwd = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--cwd=")) {
+            result.cwd = arg.slice("--cwd=".length);
+            continue;
+        }
+        if (arg === "--type") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --type.");
+            result.type = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--type=")) {
+            result.type = arg.slice("--type=".length);
+            continue;
+        }
+        if (arg === "--profile-key") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --profile-key.");
+            result.profileKey = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--profile-key=")) {
+            result.profileKey = arg.slice("--profile-key=".length);
+            continue;
+        }
+        if (arg === "--profile-name") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --profile-name.");
+            result.profileName = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--profile-name=")) {
+            result.profileName = arg.slice("--profile-name=".length);
+            continue;
+        }
+        if (arg === "--model") {
+            const val = args[i + 1];
+            if (!val) throw new Error("Missing value for --model.");
+            result.model = val;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            result.model = arg.slice("--model=".length);
+            continue;
+        }
+        if (arg === "--usage-today") {
+            result.usageToday = parseNumberFlag(args[i + 1], "--usage-today");
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--usage-today=")) {
+            result.usageToday = parseNumberFlag(
+                arg.slice("--usage-today=".length),
+                "--usage-today"
+            );
+            continue;
+        }
+        if (arg === "--usage-total") {
+            result.usageTotal = parseNumberFlag(args[i + 1], "--usage-total");
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--usage-total=")) {
+            result.usageTotal = parseNumberFlag(
+                arg.slice("--usage-total=".length),
+                "--usage-total"
+            );
+            continue;
+        }
+        if (arg === "--usage-input") {
+            result.usageInput = parseNumberFlag(args[i + 1], "--usage-input");
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--usage-input=")) {
+            result.usageInput = parseNumberFlag(
+                arg.slice("--usage-input=".length),
+                "--usage-input"
+            );
+            continue;
+        }
+        if (arg === "--usage-output") {
+            result.usageOutput = parseNumberFlag(args[i + 1], "--usage-output");
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--usage-output=")) {
+            result.usageOutput = parseNumberFlag(
+                arg.slice("--usage-output=".length),
+                "--usage-output"
+            );
+            continue;
+        }
+        if (arg === "--sync-usage") {
+            result.syncUsage = true;
+            continue;
+        }
+        throw new Error(`Unknown statusline argument: ${arg}`);
+    }
+
+    return result;
+}

package/src/cli/help.ts

@@ -0,0 +1,75 @@
+/**
+ * Help message for codenv CLI
+ */
+
+export function printHelp(): void {
+    const msg = `codenv - switch Claude/Codex env vars
+
+Usage:
+  codenv list
+  codenv ls
+  codenv config
+  codenv auto
+  codenv use
+  codenv use <profile>
+  codenv use <type> <name>
+  codenv show <profile>
+  codenv show <type> <name>
+  codenv default <profile>
+  codenv default <type> <name>
+  codenv default --clear
+  codenv remove <profile> [<profile> ...]
+  codenv remove <type> <name> [<type> <name> ...]
+  codenv remove --all
+  codenv unset
+  codenv add <profile> KEY=VALUE [KEY=VALUE ...]
+  codenv add
+  codenv launch <codex|claude> [--] [args...]
+  codenv init
+  codenv statusline [options]
+
+Options:
+  -c, --config <path>   Path to config JSON
+  -h, --help            Show help
+
+Init options:
+  --apply                 Append shell helper to your shell rc (default)
+  --print                 Print helper snippet to stdout
+  --shell <bash|zsh|fish> Explicitly set the target shell
+
+Add options:
+  -t, --type <codex|claude>   Set profile type (alias: cc)
+  -n, --note <text>           Set profile note
+  -r, --remove-file <path>    Add a removeFiles entry (repeat)
+  -x, --command <cmd>         Add a commands entry (repeat)
+  -u, --unset <KEY>           Add a global unset key (repeat)
+
+Statusline options:
+  --format <text|json>        Output format (default: text)
+  --cwd <path>                Override working directory
+  --type <type>               Set profile type
+  --profile-key <key>         Set profile key
+  --profile-name <name>       Set profile name
+  --model <model>             Set model label
+  --usage-today <n>           Set today's token usage
+  --usage-total <n>           Set total token usage
+  --usage-input <n>           Set input token usage
+  --usage-output <n>          Set output token usage
+  --sync-usage                Sync usage from sessions before reading
+
+Examples:
+  codenv init
+  codenv use codex primary
+  codenv list
+  codenv default codex primary
+  codenv remove codex primary
+  codenv remove codex primary claude default
+  codenv remove --all
+  codenv launch codex -- --help
+  codenv statusline --format json
+  CODE_ENV_CONFIG=~/.config/code-env/config.json codenv use claude default
+  codenv add --type codex primary OPENAI_BASE_URL=https://api.example.com/v1 OPENAI_API_KEY=YOUR_API_KEY
+  codenv add
+`;
+    console.log(msg);
+}

package/src/cli/index.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI module exports
+ */
+export { parseArgs, parseInitArgs, parseAddArgs, parseStatuslineArgs } from "./args";
+export { printHelp } from "./help";

package/src/commands/add.ts

@@ -0,0 +1,91 @@
+/**
+ * Add command - add/update profile configuration
+ */
+import type { Config, AddArgs } from "../types";
+import { findProfileKeysByName } from "../profile/match";
+import { generateProfileKey } from "../profile/resolve";
+
+export function addConfig(config: Config, addArgs: AddArgs): Config {
+    if (!config.profiles || typeof config.profiles !== "object") {
+        config.profiles = {};
+    }
+    let targetKey: string | null = null;
+    let matchedByName = false;
+
+    if (Object.prototype.hasOwnProperty.call(config.profiles, addArgs.profile!)) {
+        targetKey = addArgs.profile;
+    } else {
+        const matches = findProfileKeysByName(
+            config,
+            addArgs.profile!,
+            addArgs.type
+        );
+        if (matches.length === 1) {
+            targetKey = matches[0];
+            matchedByName = true;
+        } else if (matches.length > 1) {
+            const hint = addArgs.type
+                ? `Use profile key: ${matches.join(", ")}`
+                : `Use: codenv add --type <type> ${addArgs.profile} ... (or profile key: ${matches.join(
+                    ", "
+                )})`;
+            throw new Error(`Multiple profiles named "${addArgs.profile}". ${hint}`);
+        }
+    }
+
+    if (!targetKey) {
+        targetKey = generateProfileKey(config);
+        matchedByName = true;
+    }
+
+    if (!config.profiles[targetKey]) {
+        config.profiles[targetKey] = {};
+    }
+    const profile = config.profiles[targetKey];
+    if (!profile.env || typeof profile.env !== "object") {
+        profile.env = {};
+    }
+
+    if (matchedByName) {
+        profile.name = addArgs.profile!;
+    }
+
+    if (addArgs.type) {
+        profile.type = addArgs.type;
+    }
+
+    for (const pair of addArgs.pairs) {
+        const idx = pair.indexOf("=");
+        if (idx <= 0) throw new Error(`Invalid KEY=VALUE: ${pair}`);
+        const key = pair.slice(0, idx);
+        const value = pair.slice(idx + 1);
+        profile.env[key] = value;
+    }
+
+    if (addArgs.note !== null && addArgs.note !== undefined) {
+        profile.note = addArgs.note;
+    }
+
+    if (addArgs.removeFiles.length > 0) {
+        if (!Array.isArray(profile.removeFiles)) profile.removeFiles = [];
+        for (const p of addArgs.removeFiles) {
+            if (!profile.removeFiles.includes(p)) profile.removeFiles.push(p);
+        }
+    }
+
+    if (addArgs.commands.length > 0) {
+        if (!Array.isArray(profile.commands)) profile.commands = [];
+        for (const cmd of addArgs.commands) {
+            if (!profile.commands.includes(cmd)) profile.commands.push(cmd);
+        }
+    }
+
+    if (addArgs.unset.length > 0) {
+        if (!Array.isArray(config.unset)) config.unset = [];
+        for (const key of addArgs.unset) {
+            if (!config.unset.includes(key)) config.unset.push(key);
+        }
+    }
+
+    return config;
+}

package/src/commands/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Commands module exports
+ */
+export { buildUseLines, printUse } from "./use";
+export { printList } from "./list";
+export { addConfig } from "./add";
+export { printShow } from "./show";
+export { printUnset } from "./unset";
+export { runLaunch } from "./launch";
+export { printStatusline } from "./statusline";