@praeviso/code-env-switch 0.1.2 → 0.1.4

package/src/statusline/debug.ts

@@ -0,0 +1,40 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { resolvePath } from "../shell/utils";
+
+function isStatuslineDebugEnabled(): boolean {
+    const raw = process.env.CODE_ENV_STATUSLINE_DEBUG;
+    if (!raw) return false;
+    const value = String(raw).trim().toLowerCase();
+    if (!value) return false;
+    return !["0", "false", "no", "off"].includes(value);
+}
+
+function resolveDefaultConfigDir(configPath: string | null): string {
+    if (configPath) return path.dirname(configPath);
+    return path.join(os.homedir(), ".config", "code-env");
+}
+
+function getStatuslineDebugPath(configPath: string | null): string {
+    const envPath = resolvePath(process.env.CODE_ENV_STATUSLINE_DEBUG_PATH);
+    if (envPath) return envPath;
+    return path.join(resolveDefaultConfigDir(configPath), "statusline-debug.jsonl");
+}
+
+export function appendStatuslineDebug(
+    configPath: string | null,
+    payload: Record<string, unknown>
+) {
+    if (!isStatuslineDebugEnabled()) return;
+    try {
+        const debugPath = getStatuslineDebugPath(configPath);
+        const dir = path.dirname(debugPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.appendFileSync(debugPath, `${JSON.stringify(payload)}\n`, "utf8");
+    } catch {
+        // ignore debug logging failures
+    }
+}

package/src/statusline/format.ts

@@ -0,0 +1,68 @@
+import { formatTokenCount } from "../usage";
+import {
+    ICON_CONTEXT,
+    ICON_CWD,
+    ICON_MODEL,
+    ICON_PROFILE,
+    ICON_REVIEW,
+    ICON_USAGE,
+    colorize,
+    dim,
+} from "./style";
+import type { StatuslineUsage } from "./types";
+import * as path from "path";
+
+export function getCwdSegment(cwd: string): string | null {
+    if (!cwd) return null;
+    const base = path.basename(cwd) || cwd;
+    const segment = `${ICON_CWD} ${base}`;
+    return dim(segment);
+}
+
+export function formatUsageSegment(usage: StatuslineUsage | null): string | null {
+    if (!usage) return null;
+    const today =
+        usage.todayTokens ??
+        (usage.inputTokens !== null || usage.outputTokens !== null
+            ? (usage.inputTokens || 0) + (usage.outputTokens || 0)
+            : usage.totalTokens);
+    if (today === null) return null;
+    const text = `Today ${formatTokenCount(today)}`;
+    return colorize(`${ICON_USAGE} ${text}`, "33");
+}
+
+export function formatModelSegment(
+    model: string | null,
+    provider: string | null
+): string | null {
+    if (!model) return null;
+    const providerLabel = provider ? `${provider}:${model}` : model;
+    return colorize(`${ICON_MODEL} ${providerLabel}`, "35");
+}
+
+export function formatProfileSegment(
+    type: string | null,
+    profileKey: string | null,
+    profileName: string | null
+): string | null {
+    const name = profileName || profileKey;
+    if (!name) return null;
+    const label = type ? `${type}:${name}` : name;
+    return colorize(`${ICON_PROFILE} ${label}`, "37");
+}
+
+export function formatContextSegment(contextLeft: number | null): string | null {
+    if (contextLeft === null) return null;
+    const left = Math.max(0, Math.min(100, Math.round(contextLeft)));
+    return colorize(`${ICON_CONTEXT} ${left}% left`, "36");
+}
+
+export function formatContextUsedSegment(usedTokens: number | null): string | null {
+    if (usedTokens === null) return null;
+    return colorize(`${ICON_CONTEXT} ${formatTokenCount(usedTokens)} used`, "36");
+}
+
+export function formatModeSegment(reviewMode: boolean): string | null {
+    if (!reviewMode) return null;
+    return colorize(`${ICON_REVIEW} review`, "34");
+}

package/src/statusline/git.ts

@@ -0,0 +1,82 @@
+import { spawnSync } from "child_process";
+import type { GitStatus } from "./types";
+import { colorize } from "./style";
+import { ICON_GIT } from "./style";
+
+export function getGitStatus(cwd: string): GitStatus | null {
+    if (!cwd) return null;
+    const result = spawnSync("git", ["-C", cwd, "status", "--porcelain=v2", "-b"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (result.status !== 0 || !result.stdout) return null;
+    const status: GitStatus = {
+        branch: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0,
+    };
+
+    const lines = result.stdout.split(/\r?\n/);
+    for (const line of lines) {
+        if (!line) continue;
+        if (line.startsWith("# branch.head ")) {
+            status.branch = line.slice("# branch.head ".length).trim();
+            continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+            const parts = line
+                .slice("# branch.ab ".length)
+                .trim()
+                .split(/\s+/);
+            for (const part of parts) {
+                if (part.startsWith("+")) status.ahead = Number(part.slice(1)) || 0;
+                if (part.startsWith("-")) status.behind = Number(part.slice(1)) || 0;
+            }
+            continue;
+        }
+        if (line.startsWith("? ")) {
+            status.untracked += 1;
+            continue;
+        }
+        if (line.startsWith("u ")) {
+            status.conflicted += 1;
+            continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+            const parts = line.split(/\s+/);
+            const xy = parts[1] || "";
+            const staged = xy[0];
+            const unstaged = xy[1];
+            if (staged && staged !== ".") status.staged += 1;
+            if (unstaged && unstaged !== ".") status.unstaged += 1;
+            continue;
+        }
+    }
+
+    if (!status.branch) {
+        status.branch = "HEAD";
+    }
+    return status;
+}
+
+export function formatGitSegment(status: GitStatus | null): string | null {
+    if (!status || !status.branch) return null;
+    const meta: string[] = [];
+    const dirtyCount = status.staged + status.unstaged + status.untracked;
+    if (status.ahead > 0) meta.push(`↑${status.ahead}`);
+    if (status.behind > 0) meta.push(`↓${status.behind}`);
+    if (status.conflicted > 0) meta.push(`✖${status.conflicted}`);
+    if (dirtyCount > 0) meta.push(`+${dirtyCount}`);
+    const suffix = meta.length > 0 ? ` [${meta.join("")}]` : "";
+    const text = `${ICON_GIT} ${status.branch}${suffix}`;
+    const hasConflicts = status.conflicted > 0;
+    const isDirty = dirtyCount > 0;
+    if (hasConflicts) return colorize(text, "31");
+    if (isDirty) return colorize(text, "33");
+    if (status.ahead > 0 || status.behind > 0) return colorize(text, "36");
+    return colorize(text, "32");
+}