@selesai/code 0.9.14 → 0.10.0

package/dist/extensions/pi-powerline-footer/git-status.ts

@@ -1,329 +0,0 @@
-import { spawn } from "node:child_process";
-import type { GitStatus } from "./types.ts";
-
-interface CachedGitStatus {
-  staged: number;
-  unstaged: number;
-  untracked: number;
-  timestamp: number;
-}
-
-interface CachedBranch {
-  branch: string | null;
-  timestamp: number;
-}
-
-export type GitPollingMode = "full" | "branch" | "off";
-
-/** Known git hosting providers we render a dedicated icon for. */
-export type GitHost = "github" | "gitlab" | "bitbucket" | "other";
-
-interface CachedRemoteHost {
-  host: GitHost | null;
-  timestamp: number;
-}
-
-const CACHE_TTL_MS = 1000; // 1 second for file status
-const BRANCH_TTL_MS = 500; // Shorter TTL so branch updates quickly after invalidation
-const REMOTE_TTL_MS = 60_000; // Origin remote almost never changes within a session
-let cachedStatus: CachedGitStatus | null = null;
-let cachedBranch: CachedBranch | null = null;
-let cachedRemoteHost: CachedRemoteHost | null = null;
-let pendingRemoteFetch: Promise<void> | null = null;
-let pendingFetch: Promise<void> | null = null;
-let pendingBranchFetch: Promise<void> | null = null;
-let invalidationCounter = 0; // Track invalidations to prevent stale updates
-let branchInvalidationCounter = 0;
-const updateListeners = new Set<() => void>();
-
-function notifyGitUpdate(): void {
-  for (const listener of updateListeners) listener();
-}
-
-export function subscribeGitUpdates(listener: () => void): () => void {
-  updateListeners.add(listener);
-  return () => updateListeners.delete(listener);
-}
-
-/**
- * Parse git status --porcelain output
- * 
- * Format: XY filename
- * X = index status, Y = working tree status
- * ?? = untracked
- * Other X values = staged
- * Other Y values = unstaged
- */
-function parseGitStatusOutput(output: string): { staged: number; unstaged: number; untracked: number } {
-  let staged = 0;
-  let unstaged = 0;
-  let untracked = 0;
-
-  for (const line of output.split("\n")) {
-    if (!line) continue;
-    const x = line[0];
-    const y = line[1];
-
-    if (x === "?" && y === "?") {
-      untracked++;
-      continue;
-    }
-
-    // X position (index/staged)
-    if (x && x !== " " && x !== "?") {
-      staged++;
-    }
-
-    // Y position (working tree/unstaged)
-    if (y && y !== " ") {
-      unstaged++;
-    }
-  }
-
-  return { staged, unstaged, untracked };
-}
-
-/**
- * Environment for this module's read-only git commands.
- *
- * Polling `git status` otherwise refreshes the index as a side effect, taking
- * `.git/index.lock`: that races interactive git in the same repo, and orphans
- * the lock if we are killed mid-write. `GIT_OPTIONAL_LOCKS=0` skips the
- * refresh; the reported counts are unchanged. Preferred over
- * `--no-optional-locks` because it also reaches the child git processes
- * `status` spawns for submodules.
- */
-export function readOnlyGitEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
-  return { ...env, GIT_OPTIONAL_LOCKS: "0" };
-}
-
-function runGit(args: string[], timeoutMs = 200): Promise<string | null> {
-  return new Promise((resolve) => {
-    const proc = spawn("git", args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      env: readOnlyGitEnv(),
-    });
-
-    let stdout = "";
-    let resolved = false;
-
-    const finish = (result: string | null) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeoutId);
-      resolve(result);
-    };
-
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-
-    proc.on("close", (code) => {
-      finish(code === 0 ? stdout.trim() : null);
-    });
-
-    proc.on("error", () => {
-      finish(null);
-    });
-
-    const timeoutId = setTimeout(() => {
-      proc.kill();
-      finish(null);
-    }, timeoutMs);
-  });
-}
-
-/**
- * Fetch current git branch asynchronously.
- * For detached HEAD, returns the short commit SHA (matches provider's "detached" behavior).
- */
-async function fetchGitBranch(): Promise<string | null> {
-  const branch = await runGit(["branch", "--show-current"]);
-  if (branch === null) return null;
-  if (branch) return branch;
-
-  const sha = await runGit(["rev-parse", "--short", "HEAD"]);
-  return sha ? `${sha} (detached)` : "detached";
-}
-
-/**
- * Classify an origin remote URL into a known hosting provider. Handles both
- * SSH (`git@host:owner/repo`, `ssh://git@host/…`) and HTTP(S) forms, and
- * treats sub-domains (e.g. `www.github.com`) and any non-empty remote we
- * don't recognize as a generic git host.
- */
-export function detectGitHost(remoteUrl: string | null): GitHost | null {
-  if (!remoteUrl) return null;
-  const trimmed = remoteUrl.trim();
-  if (!trimmed) return null;
-
-  let host: string;
-  const scpLike = /^[^/@]+@([^:/]+):/.exec(trimmed);
-  if (scpLike) {
-    host = scpLike[1]!;
-  } else {
-    try {
-      host = new URL(trimmed).hostname;
-    } catch {
-      return "other";
-    }
-  }
-
-  host = host.toLowerCase().replace(/^www\./, "");
-  if (host === "github.com" || host.endsWith(".github.com")) return "github";
-  if (host === "gitlab.com" || host.endsWith(".gitlab.com")) return "gitlab";
-  if (host === "bitbucket.org" || host.endsWith(".bitbucket.org")) return "bitbucket";
-  return "other";
-}
-
-/**
- * Fetch the origin remote host asynchronously and cache the result.
- */
-async function fetchRemoteHost(): Promise<GitHost | null> {
-  const url = await runGit(["remote", "get-url", "origin"]);
-  return detectGitHost(url);
-}
-
-/**
- * Get the origin remote's hosting provider with a long TTL cache. Returns the
- * cached value immediately (or null before the first fetch completes) and
- * refreshes in the background, matching the branch/status caching pattern.
- */
-export function getGitRemoteHost(): GitHost | null {
-  const now = Date.now();
-  if (cachedRemoteHost && now - cachedRemoteHost.timestamp < REMOTE_TTL_MS) {
-    return cachedRemoteHost.host;
-  }
-
-  if (!pendingRemoteFetch) {
-    pendingRemoteFetch = fetchRemoteHost()
-      .then((host) => {
-        cachedRemoteHost = { host, timestamp: Date.now() };
-        notifyGitUpdate();
-      })
-      .catch(() => {
-        cachedRemoteHost = { host: null, timestamp: Date.now() };
-        notifyGitUpdate();
-      })
-      .finally(() => {
-        pendingRemoteFetch = null;
-      });
-  }
-
-  return cachedRemoteHost ? cachedRemoteHost.host : null;
-}
-
-/**
- * Fetch git status asynchronously
- */
-async function fetchGitStatus(): Promise<{ staged: number; unstaged: number; untracked: number } | null> {
-  const output = await runGit(["status", "--porcelain"], 500);
-  if (output === null) return null;
-  return parseGitStatusOutput(output);
-}
-
-/**
- * Get the current git branch with caching.
- * Falls back to provider branch if our cache is empty.
- */
-export function getCurrentBranch(providerBranch: string | null): string | null {
-  const now = Date.now();
-
-  // Return cached if fresh
-  if (cachedBranch && now - cachedBranch.timestamp < BRANCH_TTL_MS) {
-    return cachedBranch.branch;
-  }
-
-  // Trigger background fetch if not already pending
-  if (!pendingBranchFetch) {
-    const fetchId = branchInvalidationCounter;
-    pendingBranchFetch = fetchGitBranch().then((result) => {
-      // Cache result if no invalidation happened (including null for non-git dirs)
-      if (fetchId === branchInvalidationCounter) {
-        cachedBranch = {
-          branch: result,
-          timestamp: Date.now(),
-        };
-        notifyGitUpdate();
-      }
-      pendingBranchFetch = null;
-    });
-  }
-
-  // Return stale cache while refreshing; only use provider before first fetch
-  return cachedBranch ? cachedBranch.branch : providerBranch;
-}
-
-/**
- * Get git status with caching.
- * Returns cached value if within TTL, otherwise triggers async fetch.
- * This is designed for synchronous render() calls - returns last known value
- * while refreshing in background.
- */
-export function getGitStatus(providerBranch: string | null, pollingMode: GitPollingMode = "full"): GitStatus {
-  const now = Date.now();
-  const branch = pollingMode === "off" ? providerBranch : getCurrentBranch(providerBranch);
-
-  if (pollingMode !== "full") {
-    return { branch, staged: 0, unstaged: 0, untracked: 0 };
-  }
-
-  // Return cached if fresh
-  if (cachedStatus && now - cachedStatus.timestamp < CACHE_TTL_MS) {
-    return { 
-      branch, 
-      staged: cachedStatus.staged,
-      unstaged: cachedStatus.unstaged,
-      untracked: cachedStatus.untracked,
-    };
-  }
-
-  // Trigger background fetch if not already pending
-  if (!pendingFetch) {
-    const fetchId = invalidationCounter; // Capture current counter
-    pendingFetch = fetchGitStatus().then((result) => {
-      // Cache result if no invalidation happened (including null for non-git dirs)
-      if (fetchId === invalidationCounter) {
-        cachedStatus = result
-          ? { staged: result.staged, unstaged: result.unstaged, untracked: result.untracked, timestamp: Date.now() }
-          : { staged: 0, unstaged: 0, untracked: 0, timestamp: Date.now() };
-        notifyGitUpdate();
-      }
-      pendingFetch = null;
-    });
-  }
-
-  // Return last cached or empty
-  if (cachedStatus) {
-    return { 
-      branch, 
-      staged: cachedStatus.staged,
-      unstaged: cachedStatus.unstaged,
-      untracked: cachedStatus.untracked,
-    };
-  }
-
-  return { branch, staged: 0, unstaged: 0, untracked: 0 };
-}
-
-/**
- * Force refresh git status (call when you know files changed).
- * Serve-stale: keep the last known counts on screen while a background
- * refresh runs, instead of blanking the segment to zeros (footer flicker).
- */
-export function invalidateGitStatus(): void {
-  if (cachedStatus) cachedStatus.timestamp = 0; // expire, but keep serving the stale value
-  invalidationCounter++; // Increment to invalidate any pending fetches
-}
-
-/**
- * Force refresh git branch (call when you know branch might have changed).
- * Serve-stale: keep showing the last known branch until the refresh lands.
- */
-export function invalidateGitBranch(): void {
-  if (cachedBranch) cachedBranch.timestamp = 0; // expire, but keep serving the stale value
-  branchInvalidationCounter++;
-  // The origin remote is repo-scoped, so a branch/cwd change may mean a
-  // different repo; drop the host cache so it re-detects.
-  cachedRemoteHost = null;
-}

package/dist/extensions/pi-powerline-footer/guide.ts

@@ -1,220 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-
-export type GuideMode = "full" | "compact" | "off";
-export type GuideDisplayMode = "full" | "compact" | "none";
-
-export interface GuideFeature {
-  id: string;
-  section?: string;
-  title: string;
-  example: string;
-  introducedIn: string;
-}
-
-export interface GuidePreferences {
-  mode: GuideMode;
-  lastSeenVersion?: string;
-}
-
-export interface GuidePreferencesUpdate {
-  mode?: GuideMode;
-  lastSeenVersion?: string | null;
-}
-
-// Keep this map useful, not exhaustive: each row points at a real command, shortcut,
-// or prompt from the root README without reproducing the README in the overlay.
-export const GUIDE_FEATURES: readonly GuideFeature[] = [
-  {
-    id: "workflow",
-    section: "Start here",
-    title: "Workflow",
-    example: '"Use $workflow to orchestrate this implementation."',
-    introducedIn: "0.9.14",
-  },
-  {
-    id: "settings",
-    section: "Start here",
-    title: "Settings",
-    example: "/settings · /guide compact|off|reset · /reload",
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "subagents",
-    section: "Delegate / research",
-    title: "Plan",
-    example: '"Ask the architect to challenge this plan..."',
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "parallel-review",
-    section: "Delegate / research",
-    title: "Review",
-    example: '"Run parallel commentator agents for correctness..."',
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "web-research",
-    section: "Delegate / research",
-    title: "Research",
-    example: '"Ask the researcher to research <topic> and cite sources."',
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "skills",
-    section: "Delegate / research",
-    title: "Skills",
-    example: "/skill:*",
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "recovery",
-    section: "Recover",
-    title: "Recover",
-    example: "/undo · /tree · /fork · /cp <hash>",
-    introducedIn: "0.5.13",
-  },
-  {
-    id: "handoff",
-    section: "Recover",
-    title: "Handoff",
-    example: "/handoff-new Next: fix <problem>; start with a coding plan.",
-    introducedIn: "0.5.13",
-  },
-];
-
-export const GUIDE_DISMISS_HINT = "Press any key to continue";
-
-export const GUIDE_COMPACT_LINES = [
-  "/guide full · /settings",
-  '"Use $workflow to orchestrate this implementation."',
-  '"Ask the researcher to research <topic>."',
-  "/skill:* · /undo · /handoff-new <next focus>",
-] as const;
-
-export type GuideLine =
-  | { kind: "section"; text: string }
-  | { kind: "feature"; feature: GuideFeature };
-
-export function getGuideFeatureLines(features: readonly GuideFeature[] = GUIDE_FEATURES): GuideLine[] {
-  return features.flatMap((feature, index) => {
-    const previous = features[index - 1];
-    const section = feature.section && feature.section !== previous?.section
-      ? [{ kind: "section" as const, text: feature.section }]
-      : [];
-    return [...section, { kind: "feature" as const, feature }];
-  });
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isGuideMode(value: unknown): value is GuideMode {
-  return value === "full" || value === "compact" || value === "off";
-}
-
-function versionParts(version: string): [number, number, number] {
-  const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
-  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : [0, 0, 0];
-}
-
-export function compareGuideVersions(left: string, right: string): number {
-  const leftParts = versionParts(left);
-  const rightParts = versionParts(right);
-  for (let i = 0; i < leftParts.length; i++) {
-    if (leftParts[i] !== rightParts[i]) return leftParts[i] - rightParts[i];
-  }
-  return 0;
-}
-
-export function getGuidePreferences(settings: unknown): GuidePreferences {
-  const raw = isRecord(settings) && isRecord(settings.selesaiGuide)
-    ? settings.selesaiGuide
-    : {};
-
-  return {
-    mode: isGuideMode(raw.mode) ? raw.mode : "compact",
-    lastSeenVersion: typeof raw.lastSeenVersion === "string" ? raw.lastSeenVersion : undefined,
-  };
-}
-
-export function getNewGuideFeatures(
-  lastSeenVersion: string | undefined,
-  currentVersion: string,
-  features: readonly GuideFeature[] = GUIDE_FEATURES,
-): GuideFeature[] {
-  if (!lastSeenVersion || compareGuideVersions(lastSeenVersion, currentVersion) >= 0) {
-    return [];
-  }
-
-  return features.filter((feature) => (
-    compareGuideVersions(feature.introducedIn, lastSeenVersion) > 0
-    && compareGuideVersions(feature.introducedIn, currentVersion) <= 0
-  ));
-}
-
-export function resolveGuideDisplayMode(options: {
-  reason: string;
-  hasUI: boolean;
-  guideMode: GuideMode;
-}): GuideDisplayMode {
-  if (!options.hasUI || options.reason === "reload" || options.guideMode === "off") {
-    return "none";
-  }
-
-  return options.guideMode === "compact" ? "compact" : "full";
-}
-
-function readSettingsFile(settingsPath: string): Record<string, unknown> | null {
-  if (!existsSync(settingsPath)) return {};
-
-  try {
-    const parsed = JSON.parse(readFileSync(settingsPath, "utf8"));
-    return isRecord(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-export function saveGuidePreferences(
-  update: GuidePreferencesUpdate,
-  settingsPath: string,
-): boolean {
-  const settings = readSettingsFile(settingsPath);
-  if (!settings) return false;
-
-  const current = getGuidePreferences(settings);
-  const raw = isRecord(settings) && isRecord(settings.selesaiGuide)
-    ? settings.selesaiGuide
-    : {};
-  const next: Record<string, unknown> = {};
-  if (update.mode !== undefined) {
-    next.mode = update.mode;
-  } else if (typeof raw.mode === "string") {
-    // Version-only writes (markGuideVersionSeen) must preserve an explicit user
-    // mode but never persist the fallback default as a user choice.
-    next.mode = raw.mode;
-  }
-  const lastSeenVersion = update.lastSeenVersion === null
-    ? undefined
-    : update.lastSeenVersion ?? current.lastSeenVersion;
-  if (lastSeenVersion) next.lastSeenVersion = lastSeenVersion;
-
-  settings.selesaiGuide = next;
-
-  try {
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export function markGuideVersionSeen(
-  version: string,
-  settingsPath: string,
-): boolean {
-  return saveGuidePreferences({ lastSeenVersion: version }, settingsPath);
-}