@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-powerline-footer/editor-composition.ts

@@ -0,0 +1,32 @@
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+
+export function getEditorAutocompleteProvider(sourceEditor: unknown): AutocompleteProvider | undefined {
+  const candidate = sourceEditor && typeof sourceEditor === "object" ? Reflect.get(sourceEditor, "autocompleteProvider") : null;
+  if (!candidate || typeof candidate !== "object") {
+    return undefined;
+  }
+  if (typeof Reflect.get(candidate, "getSuggestions") !== "function") {
+    return undefined;
+  }
+  if (typeof Reflect.get(candidate, "applyCompletion") !== "function") {
+    return undefined;
+  }
+  return candidate;
+}
+
+export function passAutocompleteProviderThroughPreviousEditor(
+  provider: AutocompleteProvider,
+  previousEditor: unknown,
+): AutocompleteProvider {
+  if (!previousEditor || typeof previousEditor !== "object") {
+    return provider;
+  }
+
+  const setAutocompleteProvider = Reflect.get(previousEditor, "setAutocompleteProvider");
+  if (typeof setAutocompleteProvider !== "function") {
+    return getEditorAutocompleteProvider(previousEditor) ?? provider;
+  }
+
+  setAutocompleteProvider.call(previousEditor, provider);
+  return getEditorAutocompleteProvider(previousEditor) ?? provider;
+}

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

@@ -13,14 +13,37 @@ interface CachedBranch {
   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
@@ -108,6 +131,73 @@ async function fetchGitBranch(): Promise<string | null> {
   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
  */
@@ -139,6 +229,7 @@ export function getCurrentBranch(providerBranch: string | null): string | null {
           branch: result,
           timestamp: Date.now(),
         };
+        notifyGitUpdate();
       }
       pendingBranchFetch = null;
     });
@@ -154,9 +245,13 @@ export function getCurrentBranch(providerBranch: string | null): string | null {
  * This is designed for synchronous render() calls - returns last known value
  * while refreshing in background.
  */
-export function getGitStatus(providerBranch: string | null): GitStatus {
+export function getGitStatus(providerBranch: string | null, pollingMode: GitPollingMode = "full"): GitStatus {
   const now = Date.now();
-  const branch = getCurrentBranch(providerBranch);
+  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) {
@@ -177,6 +272,7 @@ export function getGitStatus(providerBranch: string | null): GitStatus {
         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;
     });
@@ -196,17 +292,23 @@ export function getGitStatus(providerBranch: string | null): GitStatus {
 }
 
 /**
- * Force refresh git status (call when you know files changed)
+ * 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 {
-  cachedStatus = null;
+  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)
+ * 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 {
-  cachedBranch = null;
+  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/icons.ts

@@ -6,6 +6,9 @@ export interface IconSet {
   folder: string;
   branch: string;
   git: string;
+  github: string;
+  gitlab: string;
+  bitbucket: string;
   tokens: string;
   context: string;
   cost: string;
@@ -56,8 +59,11 @@ export const NERD_ICONS: IconSet = {
   folder: "\uF115",     // nf-fa-folder_open
   branch: "\uF126",     // nf-fa-code_fork (git branch)
   git: "\uF1D3",        // nf-fa-git (git logo)
+  github: "\uF09B",     // nf-fa-github (octocat)
+  gitlab: "\uF296",     // nf-fa-gitlab (tanuki)
+  bitbucket: "\uF171",  // nf-fa-bitbucket
   tokens: "\uE26B",     // nf-seti-html (tokens symbol)
-  context: "\uE70F",    // nf-dev-database (database)
+  context: "\uF1C0",    // nf-fa-database (stable Nerd Fonts v3 database)
   cost: "\uF155",       // nf-fa-dollar
   time: "\uF017",       // nf-fa-clock_o
   agents: "\uF0C0",     // nf-fa-users
@@ -77,6 +83,9 @@ export const ASCII_ICONS: IconSet = {
   folder: "dir",
   branch: "⎇",
   git: "⎇",
+  github: "⎇",
+  gitlab: "⎇",
+  bitbucket: "⎇",
   tokens: "⊛",
   context: "◫",
   cost: "$",
@@ -101,7 +110,7 @@ function sanitizeUserIconOverrides(value: unknown): PartialIconSet {
   const sanitized: PartialIconSet = {};
   const validKeys = Object.keys(NERD_ICONS) as Array<keyof IconSet>;
   for (const key of validKeys) {
-    const icon = value[key];
+    const icon = Reflect.get(value, key);
     if (typeof icon === "string") {
       sanitized[key] = icon;
     }