@groeponline/pi-wishcraft 0.17.3

package/src/extension/welcome-integration.ts

@@ -0,0 +1,153 @@
+import {
+  WelcomeComponent,
+  WelcomeHeader,
+  discoverLoadedCounts,
+  getRecentSessions,
+} from "../welcome/index.ts";
+import { estimateInitialContextTokens } from "../usage/context.ts";
+import { isRecord } from "./settings-io.ts";
+import type { RuntimeState } from "./types.ts";
+import { getQueueContext } from "./queue-context.ts";
+
+export function setupWelcomeHeader(rt: RuntimeState, ctx: any) {
+  const modelName = ctx.model?.name || ctx.model?.id || "No model";
+  const providerName = ctx.model?.provider || "Unknown";
+  const loadedCounts = discoverLoadedCounts();
+  const recentSessions = getRecentSessions(3);
+  const initialContextTokens = estimateInitialContextTokens(ctx);
+  const queueSummary = rt.queueStore.summarize(getQueueContext(ctx), false);
+  const queueCount = queueSummary.queueCount + queueSummary.ideaCount;
+  const hasStash = rt.stashedEditorText !== null || rt.stashedPromptHistory.length > 0;
+
+  const header = new WelcomeHeader(
+    modelName,
+    providerName,
+    recentSessions,
+    loadedCounts,
+    initialContextTokens,
+    queueCount,
+    hasStash,
+  );
+  rt.welcomeHeaderActive = true;
+
+  ctx.ui.setHeader(() => {
+    return {
+      render(width: number): string[] {
+        return header.render(width);
+      },
+      invalidate() {
+        header.invalidate();
+      },
+    };
+  });
+}
+
+export function setupWelcomeOverlay(rt: RuntimeState, ctx: any) {
+  const modelName = ctx.model?.name || ctx.model?.id || "No model";
+  const providerName = ctx.model?.provider || "Unknown";
+  const loadedCounts = discoverLoadedCounts();
+  const recentSessions = getRecentSessions(3);
+
+  const overlaySessionGeneration = rt.sessionGeneration;
+
+  // Small delay to let pi-mono finish initialization
+  setTimeout(() => {
+    if (
+      !rt.enabled ||
+      rt.welcomeOverlayShouldDismiss ||
+      rt.isStreaming ||
+      overlaySessionGeneration !== rt.sessionGeneration
+    ) {
+      rt.welcomeOverlayShouldDismiss = false;
+      return;
+    }
+
+    const sessionEvents = ctx.sessionManager?.getBranch?.() ?? [];
+    const hasActivity = sessionEvents.some((entry: unknown) => {
+      if (!isRecord(entry)) return false;
+      if (entry.type === "tool_call" || entry.type === "tool_result")
+        return true;
+      return (
+        entry.type === "message" &&
+        isRecord(entry.message) &&
+        entry.message.role === "assistant"
+      );
+    });
+    if (hasActivity) {
+      return;
+    }
+
+    const initialContextTokens = estimateInitialContextTokens(ctx);
+    const queueSummary = rt.queueStore.summarize(getQueueContext(ctx), false);
+    const queueCount = queueSummary.queueCount + queueSummary.ideaCount;
+    const hasStash = rt.stashedEditorText !== null || rt.stashedPromptHistory.length > 0;
+
+    ctx.ui
+      .custom(
+        (
+          tui: any,
+          _theme: any,
+          _keybindings: any,
+          done: (result: void) => void,
+        ) => {
+          const welcome = new WelcomeComponent(
+            modelName,
+            providerName,
+            recentSessions,
+            loadedCounts,
+            initialContextTokens,
+            queueCount,
+            hasStash,
+          );
+
+          let countdown = 30;
+          let dismissed = false;
+          let interval: ReturnType<typeof setInterval> | null = null;
+
+          const dismiss = () => {
+            if (dismissed) return;
+            dismissed = true;
+            if (interval) clearInterval(interval);
+            rt.dismissWelcomeOverlay = null;
+            done();
+          };
+
+          interval = setInterval(() => {
+            if (dismissed) return;
+            countdown--;
+            welcome.setCountdown(countdown);
+            tui.requestRender();
+            if (countdown <= 0) dismiss();
+          }, 1000);
+
+          rt.dismissWelcomeOverlay = dismiss;
+
+          if (rt.welcomeOverlayShouldDismiss) {
+            rt.welcomeOverlayShouldDismiss = false;
+            dismiss();
+          }
+
+          return {
+            focused: false,
+            invalidate: () => welcome.invalidate(),
+            render: (width: number) => welcome.render(width),
+            handleInput: () => dismiss(),
+            dispose: () => {
+              dismissed = true;
+              if (interval) clearInterval(interval);
+            },
+          };
+        },
+        {
+          overlay: true,
+          overlayOptions: () => ({
+            verticalAlign: "center",
+            horizontalAlign: "center",
+          }),
+        },
+      )
+      .catch((error: unknown) => {
+        console.debug("[powerline-footer] Welcome overlay failed:", error);
+      });
+  }, 100);
+}

package/src/git/status.ts

@@ -0,0 +1,332 @@
+import { spawn } from "node:child_process";
+import type { GitStatus } from "../config/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 };
+}
+
+function runGit(args: string[], timeoutMs = 200): Promise<string | null> {
+  return new Promise((resolve) => {
+    const proc = spawn("git", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    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/src/paths/agent-dirs.ts

@@ -0,0 +1,67 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { join, resolve } from "node:path";
+
+/**
+ * Returns the current user's home directory.
+ */
+export function getHomeDir(): string {
+  return process.env.HOME || process.env.USERPROFILE || homedir();
+}
+
+/**
+ * Normalizes a path string by expanding tildes and handling file:// URLs.
+ */
+export function normalizeAgentDirPath(value: string): string {
+  const trimmed = value.trim();
+  
+  if (trimmed.startsWith("file://")) {
+    return fileURLToPath(new URL(trimmed));
+  }
+
+  if (trimmed === "~" || trimmed.startsWith("~/") || (process.platform === "win32" && trimmed.startsWith("~\\"))) {
+    const withoutTilde = trimmed.substring(1);
+    return resolve(getHomeDir(), `.${withoutTilde}`);
+  }
+  
+  return trimmed;
+}
+
+/**
+ * Returns the active pi-coding-agent directory path.
+ */
+export function getAgentDir(): string {
+  const configured = process.env.PI_CODING_AGENT_DIR;
+  if (configured && configured.trim().length > 0) {
+    return normalizeAgentDirPath(configured);
+  }
+  return join(getHomeDir(), ".pi", "agent");
+}
+
+/**
+ * Returns an absolute path within the pi-coding-agent directory.
+ */
+export function getAgentPath(...segments: string[]): string {
+  return join(getAgentDir(), ...segments);
+}
+
+/**
+ * Returns an absolute path within the legacy .pi directory.
+ */
+export function getLegacyPiPath(...segments: string[]): string {
+  return join(getHomeDir(), ".pi", ...segments);
+}
+
+/**
+ * Returns a list of candidate directories for storing sessions.
+ */
+export function getAgentSessionDirs(): string[] {
+  const primary = getAgentPath("sessions");
+  const legacy = getLegacyPiPath("sessions");
+  
+  if (primary !== legacy && existsSync(legacy)) {
+    return [primary, legacy];
+  }
+  return [primary];
+}

package/src/render/timer.ts

@@ -0,0 +1,46 @@
+export interface RenderScheduler {
+  schedule(delayMs?: number): void;
+  cancel(): void;
+}
+
+export function createCoalescingTimer(render: () => void, defaultDelayMs: number): RenderScheduler {
+  let activeTimer: ReturnType<typeof setTimeout> | null = null;
+  let targetTime: number | null = null;
+  let runId = 0;
+
+  return {
+    schedule(delayMs = defaultDelayMs) {
+      const now = Date.now();
+      const nextRunTime = now + delayMs;
+      
+      if (activeTimer !== null && targetTime !== null && targetTime <= nextRunTime) {
+        return;
+      }
+      
+      if (activeTimer !== null) {
+        clearTimeout(activeTimer);
+      }
+      
+      targetTime = nextRunTime;
+      const currentRunId = ++runId;
+      
+      activeTimer = setTimeout(() => {
+        if (currentRunId === runId) {
+          activeTimer = null;
+          targetTime = null;
+          render();
+        }
+      }, delayMs);
+    },
+    cancel() {
+      if (activeTimer !== null) {
+        clearTimeout(activeTimer);
+        activeTimer = null;
+        targetTime = null;
+      }
+      runId++;
+    }
+  };
+}
+
+export const createRenderScheduler = createCoalescingTimer;