@groeponline/pi-wishcraft 0.17.3

package/src/welcome/renderer.ts

@@ -0,0 +1,157 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { ansi, fgOnly, getFgAnsiCode } from "../theme/colors.ts";
+import { centerText, fitToWidth, getBoxLayout } from "./layout.ts";
+import type { WelcomeData, WelcomeWidget, WidgetRenderContext } from "./types.ts";
+
+import { QueueWidget } from "./widgets/queue-widget.ts";
+import { SessionsWidget } from "./widgets/sessions-widget.ts";
+import { ShortcutsWidget } from "./widgets/shortcuts-widget.ts";
+import { SystemWidget } from "./widgets/system-widget.ts";
+
+const PI_LOGO = [
+  "     . *      ",
+  "   * ╭───╮ .  ",
+  "  .  │   │  * ",
+  "     │   │    ",
+  "   * ╰─┬─╯ .  ",
+  "  .    ┴      ",
+];
+
+const GRADIENT_COLORS = [
+  "\x1b[38;5;199m",
+  "\x1b[38;5;171m",
+  "\x1b[38;5;135m",
+  "\x1b[38;5;99m",
+  "\x1b[38;5;75m",
+  "\x1b[38;5;51m",
+];
+
+function bold(text: string): string {
+  return `\x1b[1m${text}\x1b[22m`;
+}
+
+export function dim(text: string): string {
+  return getFgAnsiCode("sep") + text + ansi.reset;
+}
+
+function gradientLine(line: string): string {
+  const reset = ansi.reset;
+  let result = "";
+  let colorIdx = 0;
+  const step = Math.max(1, Math.floor(line.length / GRADIENT_COLORS.length));
+
+  for (let i = 0; i < line.length; i++) {
+    if (i > 0 && i % step === 0 && colorIdx < GRADIENT_COLORS.length - 1)
+      colorIdx++;
+    const char = line[i];
+    if (char !== " ") {
+      result += GRADIENT_COLORS[colorIdx] + char + reset;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+function buildLeftColumn(ctx: WidgetRenderContext): string[] {
+  const logoColored = PI_LOGO.map((line) => gradientLine(line));
+
+  return [
+    "",
+    ...logoColored.map((l) => centerText(l, ctx.width)),
+    "",
+    centerText(fgOnly("model", ctx.data.modelName), ctx.width),
+    centerText(dim(ctx.data.providerName), ctx.width),
+  ];
+}
+
+function buildRightColumn(
+  ctx: WidgetRenderContext,
+  widgets: WelcomeWidget[]
+): string[] {
+  const hChar = "─";
+  const separator = ` ${dim(hChar.repeat(Math.max(1, ctx.width - 2)))}`;
+  const lines: string[] = [];
+
+  lines.push(` ${bold(fgOnly("accent", "Signals & Wishes"))}`);
+  lines.push(` ${dim("Write it down, let it rise, keep your focus clear.")}`);
+  lines.push(separator);
+
+  for (let i = 0; i < widgets.length; i++) {
+    const wLines = widgets[i].render(ctx);
+    lines.push(...wLines);
+    if (i < widgets.length - 1) {
+      lines.push(separator);
+    }
+  }
+
+  lines.push("");
+  return lines;
+}
+
+export function renderWelcomeBox(
+  data: WelcomeData,
+  termWidth: number,
+  bottomLine: string,
+): string[] {
+  const layout = getBoxLayout(termWidth);
+  if (!layout) {
+    return [];
+  }
+
+  const { boxWidth, leftCol, rightCol } = layout;
+
+  const hChar = "─";
+  const v = dim("│");
+  const tl = dim("╭");
+  const tr = dim("╮");
+  const bl = dim("╰");
+  const br = dim("╯");
+
+  const rightWidgets = [
+    SystemWidget,
+    QueueWidget,
+    ShortcutsWidget,
+    SessionsWidget,
+  ];
+
+  const leftCtx: WidgetRenderContext = {
+    data,
+    width: leftCol,
+    dim,
+    bold,
+    color: fgOnly,
+  };
+
+  const rightCtx: WidgetRenderContext = {
+    data,
+    width: rightCol,
+    dim,
+    bold,
+    color: fgOnly,
+  };
+
+  const leftLines = buildLeftColumn(leftCtx);
+  const rightLines = buildRightColumn(rightCtx, rightWidgets);
+
+  const lines: string[] = [];
+
+  const title = " pi-wishcraft ";
+  const titlePrefix = dim(hChar.repeat(3));
+  const titleStyled = titlePrefix + fgOnly("model", title);
+  const titleVisLen = 3 + visibleWidth(title);
+  const afterTitle = boxWidth - 2 - titleVisLen;
+  const afterTitleText = afterTitle > 0 ? dim(hChar.repeat(afterTitle)) : "";
+  lines.push(tl + titleStyled + afterTitleText + tr);
+
+  const maxRows = Math.max(leftLines.length, rightLines.length);
+  for (let i = 0; i < maxRows; i++) {
+    const left = fitToWidth(leftLines[i] ?? "", leftCol);
+    const right = fitToWidth(rightLines[i] ?? "", rightCol);
+    lines.push(v + left + v + right + v);
+  }
+
+  lines.push(bl + bottomLine + br);
+
+  return lines;
+}

package/src/welcome/sessions.ts

@@ -0,0 +1,107 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { getAgentSessionDirs } from "../paths/agent-dirs.ts";
+import { logDiscoveryError } from "./discover.ts";
+import { formatTimeAgo } from "./format.ts";
+import type { RecentSession } from "./types.ts";
+
+const MAX_HEADER_SIZE = 8192;
+
+interface SessionRecord {
+  name: string;
+  mtime: number;
+}
+
+function parseProjectNameFromHeader(filePath: string): string | null {
+  try {
+    const buffer = readFileSync(filePath);
+    const bytesToRead = Math.min(buffer.length, MAX_HEADER_SIZE);
+    const firstLine = buffer
+      .toString("utf8", 0, bytesToRead)
+      .split(/\r?\n/, 1)[0]
+      ?.trim();
+      
+    if (!firstLine) return null;
+
+    const header: unknown = JSON.parse(firstLine);
+    
+    if (typeof header !== "object" || header === null) return null;
+    if (!("cwd" in header)) return null;
+    
+    const cwd = (header as { cwd: unknown }).cwd;
+    if (typeof cwd !== "string" || cwd.trim().length === 0) return null;
+
+    return basename(cwd) || cwd;
+  } catch {
+    return null;
+  }
+}
+
+function extractProjectNameFromDir(dir: string): string {
+  const parentName = basename(dir);
+  if (!parentName.startsWith("--")) {
+    return parentName;
+  }
+
+  const parts = parentName.split("-").filter(Boolean);
+  return parts[parts.length - 1] || parentName;
+}
+
+function scanSessionDirectory(dir: string, sessions: SessionRecord[]): void {
+  if (!existsSync(dir)) return;
+  
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const entryPath = join(dir, entry);
+      try {
+        const stats = statSync(entryPath);
+        if (stats.isDirectory()) {
+          scanSessionDirectory(entryPath, sessions);
+        } else if (entry.endsWith(".jsonl")) {
+          const projectName =
+            parseProjectNameFromHeader(entryPath) ??
+            extractProjectNameFromDir(dir);
+          sessions.push({ name: projectName, mtime: stats.mtimeMs });
+        }
+      } catch (error) {
+        logDiscoveryError(`Failed to inspect session entry ${entryPath}`, error);
+      }
+    }
+  } catch (error) {
+    logDiscoveryError(`Failed to scan sessions dir ${dir}`, error);
+  }
+}
+
+function filterAndFormatSessions(sessions: SessionRecord[], maxCount: number): RecentSession[] {
+  if (sessions.length === 0) return [];
+
+  sessions.sort((a, b) => b.mtime - a.mtime);
+
+  const seen = new Set<string>();
+  const uniqueSessions: SessionRecord[] = [];
+  
+  for (const s of sessions) {
+    if (!seen.has(s.name)) {
+      seen.add(s.name);
+      uniqueSessions.push(s);
+    }
+  }
+
+  const now = Date.now();
+  return uniqueSessions.slice(0, maxCount).map((s) => ({
+    name: s.name.length > 20 ? s.name.slice(0, 17) + "…" : s.name,
+    timeAgo: formatTimeAgo(now - s.mtime),
+  }));
+}
+
+export function getRecentSessions(maxCount: number = 3): RecentSession[] {
+  const sessionsDirs = getAgentSessionDirs();
+  const sessions: SessionRecord[] = [];
+
+  for (const dir of sessionsDirs) {
+    scanSessionDirectory(dir, sessions);
+  }
+
+  return filterAndFormatSessions(sessions, maxCount);
+}

package/src/welcome/types.ts

@@ -0,0 +1,41 @@
+export interface LoadedCounts {
+  contextFiles: number;
+  extensions: number;
+  skills: number;
+  promptTemplates: number;
+}
+
+export interface RecentSession {
+  name: string;
+  timeAgo: string;
+}
+
+export interface WelcomeData {
+  modelName: string;
+  providerName: string;
+  recentSessions: RecentSession[];
+  loadedCounts: LoadedCounts;
+  initialContextTokens: number | null;
+  queueCount?: number;
+  hasStash?: boolean;
+}
+
+export interface WelcomeWidget {
+  id: string;
+  render(ctx: WidgetRenderContext): string[];
+}
+
+export interface WidgetRenderContext {
+  data: WelcomeData;
+  width: number;
+  dim: (text: string) => string;
+  bold: (text: string) => string;
+  color: (semantic: string, text: string) => string;
+}
+
+export interface WelcomeLayoutConfig {
+  width: number;
+  padding: number;
+  columnGap: number;
+  breakpoint: number;
+}

package/src/welcome/widgets/graph-widget.ts

@@ -0,0 +1,25 @@
+import type { WelcomeWidget, WidgetRenderContext } from "../types.ts";
+import { renderSparkline } from "../../tools/graph.ts";
+
+/**
+ * Graph widget that renders a mini token sparkline and telemetry activity.
+ */
+export const graphWidget: WelcomeWidget = {
+  id: "graph",
+  render(ctx: WidgetRenderContext): string[] {
+    const lines: string[] = [];
+    const hChar = "─";
+    const separator = ` ${ctx.dim(hChar.repeat(Math.max(1, ctx.width - 2)))}`;
+
+    lines.push(` ${ctx.bold(ctx.color("accent", "Telemetry Sparkline"))}`);
+
+    // Sample usage trend points
+    const sampleData = [1200, 2400, 3100, 2800, 4500, 6200, 8900, 11400, 9800, 12400];
+    const sparkline = renderSparkline(sampleData, 12);
+    
+    lines.push(` ${ctx.dim("activity:")} ${ctx.color("gitClean", sparkline)} ${ctx.dim("12.4k tok")}`);
+    lines.push(separator);
+
+    return lines;
+  },
+};

package/src/welcome/widgets/index.ts

@@ -0,0 +1,20 @@
+import type { WelcomeWidget } from "../types.ts";
+import { SystemWidget } from "./system-widget.ts";
+import { QueueWidget } from "./queue-widget.ts";
+import { ShortcutsWidget } from "./shortcuts-widget.ts";
+import { SessionsWidget } from "./sessions-widget.ts";
+import { graphWidget } from "./graph-widget.ts";
+
+export { SystemWidget } from "./system-widget.ts";
+export { QueueWidget } from "./queue-widget.ts";
+export { ShortcutsWidget } from "./shortcuts-widget.ts";
+export { SessionsWidget } from "./sessions-widget.ts";
+export { graphWidget } from "./graph-widget.ts";
+
+export const ALL_WELCOME_WIDGETS: WelcomeWidget[] = [
+  SystemWidget,
+  graphWidget,
+  QueueWidget,
+  ShortcutsWidget,
+  SessionsWidget,
+];

package/src/welcome/widgets/queue-widget.ts

@@ -0,0 +1,26 @@
+import type { WelcomeWidget, WidgetRenderContext } from "../types.ts";
+
+export const QueueWidget: WelcomeWidget = {
+  id: "queue",
+  render(ctx: WidgetRenderContext): string[] {
+    const { data, dim, color } = ctx;
+    const lines: string[] = [];
+    
+    const prefix = dim("- ");
+    if (data.queueCount && data.queueCount > 0) {
+      lines.push(` ${prefix}${color("gitClean", `${data.queueCount}`)} queued items ready`);
+    } else {
+      lines.push(` ${prefix}type ${color("model", "# <idea>")} to capture a thought`);
+    }
+
+    if (data.hasStash) {
+      lines.push(` ${prefix}${color("gitClean", "1")} draft stashed (Alt+S to pop)`);
+    } else {
+      lines.push(` ${prefix}press ${color("model", "alt+s")} to park a draft`);
+    }
+
+    lines.push(` ${prefix}${dim("dreaming & mission queue ready")}`);
+    
+    return lines;
+  }
+};

package/src/welcome/widgets/sessions-widget.ts

@@ -0,0 +1,23 @@
+import type { WelcomeWidget, WidgetRenderContext } from "../types.ts";
+
+export const SessionsWidget: WelcomeWidget = {
+  id: "sessions",
+  render(ctx: WidgetRenderContext): string[] {
+    const { data, dim, bold, color } = ctx;
+    const lines: string[] = [];
+    
+    lines.push(` ${bold(color("accent", "Recent Crafts"))}`);
+    
+    if (data.recentSessions.length === 0) {
+      lines.push(` ${dim("No recent sessions")}`);
+    } else {
+      for (const session of data.recentSessions.slice(0, 3)) {
+        lines.push(
+          ` ${dim("• ")}${color("path", session.name)}${dim(` (${session.timeAgo})`)}`
+        );
+      }
+    }
+    
+    return lines;
+  }
+};

package/src/welcome/widgets/shortcuts-widget.ts

@@ -0,0 +1,17 @@
+import type { WelcomeWidget, WidgetRenderContext } from "../types.ts";
+
+export const ShortcutsWidget: WelcomeWidget = {
+  id: "shortcuts",
+  render(ctx: WidgetRenderContext): string[] {
+    const { dim, bold, color } = ctx;
+    const lines: string[] = [];
+    
+    lines.push(` ${bold(color("accent", "Quick Launch / Tactical"))}`);
+    lines.push(` ${dim("# <idea>  ")} capture idea to queue`);
+    lines.push(` ${dim("alt+p     ")} tactical powerline overlay`);
+    lines.push(` ${dim("!cmd      ")} sticky bash session`);
+    lines.push(` ${dim("alt+s     ")} stash/pop prompt draft`);
+    
+    return lines;
+  }
+};

package/src/welcome/widgets/system-widget.ts

@@ -0,0 +1,29 @@
+import { formatTokens } from "../format.ts";
+import type { WelcomeWidget, WidgetRenderContext } from "../types.ts";
+
+export const SystemWidget: WelcomeWidget = {
+  id: "system",
+  render(ctx: WidgetRenderContext): string[] {
+    const { data, dim, bold, color } = ctx;
+    const lines: string[] = [];
+    
+    const prefix = dim("- ");
+    lines.push(` ${bold(color("accent", "Active Horizon"))}`);
+    
+    lines.push(` ${prefix}Model: ${color("model", data.modelName)} (${dim(data.providerName)})`);
+    
+    if (data.initialContextTokens !== null && data.initialContextTokens > 0) {
+      lines.push(
+        ` ${prefix}${color("gitClean", `≈ ${formatTokens(data.initialContextTokens)}`)} initial prompt tokens`
+      );
+    }
+    
+    const { extensions, skills } = data.loadedCounts;
+    const toolsCount = extensions + skills;
+    if (toolsCount > 0) {
+      lines.push(` ${prefix}${color("gitClean", `${toolsCount}`)} skills/extensions loaded`);
+    }
+    
+    return lines;
+  }
+};

package/src/working-vibes/generate.ts

@@ -0,0 +1,144 @@
+// generate.ts
+// CLI-arg parsing and batch generation for `/vibe generate`.
+
+import {
+  BATCH_PROMPT,
+  getVibeFilePath,
+  saveVibesToFile,
+  vibeState,
+} from "./storage.ts";
+import { buildAiContext, completeVibe } from "./provider.ts";
+
+export type GenerateVibesResult =
+  | { success: true; count: number; filePath: string }
+  | { success: false; count: 0; filePath: string; error: string };
+
+export function parseVibeGenerateArgs(
+  args: readonly string[],
+): { theme: string; count: number } | null {
+  if (args.length === 0) return null;
+
+  const last = args.at(-1);
+  const parsedCount =
+    last && /^\d+$/.test(last) ? Number.parseInt(last, 10) : Number.NaN;
+  const hasCount = Number.isFinite(parsedCount) && args.length > 1;
+  const theme = hasCount ? args.slice(0, -1).join(" ") : args.join(" ");
+  if (!theme) return null;
+
+  return {
+    theme,
+    count: hasCount ? Math.min(Math.max(Math.floor(parsedCount), 1), 500) : 100,
+  };
+}
+
+export async function generateVibesBatch(
+  theme: string,
+  count: number = 100,
+): Promise<GenerateVibesResult> {
+  const filePath = getVibeFilePath(theme);
+  const safeCount = Number.isFinite(count)
+    ? Math.min(Math.max(Math.floor(count), 1), 500)
+    : 100;
+
+  if (!vibeState.extensionCtx) {
+    return {
+      success: false,
+      count: 0,
+      filePath,
+      error: "Extension not initialized",
+    };
+  }
+
+  // Parse model spec
+  const slashIndex = vibeState.config.modelSpec.indexOf("/");
+  if (slashIndex === -1) {
+    return { success: false, count: 0, filePath, error: "Invalid model spec" };
+  }
+  const provider = vibeState.config.modelSpec.slice(0, slashIndex);
+  const modelId = vibeState.config.modelSpec.slice(slashIndex + 1);
+
+  // Resolve model
+  const model = vibeState.extensionCtx.modelRegistry.find(provider, modelId);
+  if (!model) {
+    return {
+      success: false,
+      count: 0,
+      filePath,
+      error: `Model not found: ${vibeState.config.modelSpec}`,
+    };
+  }
+
+  // Get auth
+  const auth =
+    await vibeState.extensionCtx.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok) {
+    return { success: false, count: 0, filePath, error: auth.error };
+  }
+
+  // Build batch prompt
+  const prompt = BATCH_PROMPT.replace(/\{theme\}/g, theme).replace(
+    /\{count\}/g,
+    String(safeCount),
+  );
+
+  const aiContext = buildAiContext(prompt);
+
+  try {
+    // Use longer timeout for batch generation (30 seconds)
+    const signal = AbortSignal.timeout(30000);
+    const response = await completeVibe(provider, model, aiContext, {
+      apiKey: auth.apiKey,
+      headers: auth.headers,
+      env: auth.env,
+      signal,
+    });
+
+    const textContent = response.content.find((c) => c.type === "text");
+    if (!textContent?.text) {
+      const error =
+        response.stopReason === "error" && response.errorMessage
+          ? response.errorMessage
+          : "Empty response from model";
+      return { success: false, count: 0, filePath, error };
+    }
+
+    // Parse response: one vibe per line
+    const vibes = textContent.text
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        // Clean up each line
+        let vibe = line.replace(/^["'\d.\-)\s]+/, "").trim(); // Remove leading quotes, numbers, bullets
+        vibe = vibe.replace(/["']$/g, ""); // Remove trailing quotes
+        if (!vibe.endsWith("...")) {
+          vibe = vibe.replace(/\.+$/, "") + "...";
+        }
+        return vibe;
+      })
+      .filter((vibe) => vibe.length > 3 && vibe !== "..."); // Filter invalid
+
+    if (vibes.length === 0) {
+      return {
+        success: false,
+        count: 0,
+        filePath,
+        error: "No valid vibes generated",
+      };
+    }
+
+    // Save to file
+    saveVibesToFile(theme, vibes);
+
+    // Clear cache so next use loads fresh
+    if (vibeState.vibeCacheTheme === theme) {
+      vibeState.vibeCache = [];
+      vibeState.vibeCacheTheme = null;
+    }
+
+    return { success: true, count: vibes.length, filePath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, count: 0, filePath, error: message };
+  }
+}

package/src/working-vibes/index.ts

@@ -0,0 +1,24 @@
+// index.ts
+// Barrel re-exporting the public API for working-vibes
+// (AI-generated contextual working messages that match a user's preferred theme/vibe).
+
+export {
+  initVibeManager,
+  getVibeTheme,
+  setVibeTheme,
+  getVibeModel,
+  setVibeModel,
+  onVibeBeforeAgentStart,
+  onVibeAgentStart,
+  onVibeToolCall,
+  onVibeAgentEnd,
+  getVibeMode,
+  setVibeMode,
+  hasVibeFile,
+  getVibeFileCount,
+} from "./manager.ts";
+
+export type { VibeMode } from "./storage.ts";
+
+export type { GenerateVibesResult } from "./generate.ts";
+export { parseVibeGenerateArgs, generateVibesBatch } from "./generate.ts";