@xpufx/paseo-forges 0.1.0

package/client/label-chip.tsx

@@ -0,0 +1,116 @@
+import React from "react";
+import { View, type StyleProp, type ViewStyle } from "react-native";
+import { Badge, usePluginTheme } from "paseo-plugin-helper/client";
+import { planLabelChip, type ForgeLabel, type LabelChipHalf } from "../shared/issues.js";
+
+/** Inner corners join the halves; the scope's right border becomes the divider. */
+function halfEdgeStyle(side: "scope" | "value"): ViewStyle {
+  return side === "scope"
+    ? { borderTopRightRadius: 0, borderBottomRightRadius: 0 }
+    : { borderTopLeftRadius: 0, borderBottomLeftRadius: 0, borderLeftWidth: 0 };
+}
+
+/**
+ * Width guard shared by every chip. `flexShrink` lets chips surrender space to
+ * their neighbours on a wrap line instead of each claiming its own, and the cap
+ * stops one from spilling past the row. The value half is pre-truncated by
+ * `planLabelChip`, so this is a bound, not the primary compaction.
+ */
+const CHIP_WIDTH_STYLE: ViewStyle = { flexShrink: 1, maxWidth: "100%" };
+
+function ChipHalf({
+  half,
+  side,
+  ring,
+  query,
+}: {
+  half: LabelChipHalf;
+  side?: "scope" | "value";
+  ring?: StyleProp<ViewStyle>;
+  query?: string;
+}) {
+  const filled = Boolean(half.background && half.textColor);
+  const fillStyle: ViewStyle = filled
+    ? { backgroundColor: half.background, borderColor: half.background }
+    : {};
+  return (
+    <Badge
+      variant="neutral"
+      styleVariant={filled ? "solid" : "tinted"}
+      size="sm"
+      label={half.text}
+      highlightQuery={query}
+      style={[CHIP_WIDTH_STYLE, side ? halfEdgeStyle(side) : undefined, fillStyle, ring]}
+      textStyle={filled ? { color: half.textColor } : undefined}
+    />
+  );
+}
+
+/**
+ * One Forgejo-style label pill. A scoped name (`scope/value`) always renders as
+ * two segments — the scope in a darker shade of the API color, the value in the
+ * base color — and never as the raw slash form; without a usable color both
+ * segments fall back to the neutral theme chip, still split. Every label
+ * surface routes through this component.
+ */
+export function LabelChip({
+  label,
+  selected = false,
+  query,
+}: {
+  label: ForgeLabel;
+  selected?: boolean;
+  query?: string;
+}) {
+  const { colors, resolveRadius } = usePluginTheme();
+  const ring: StyleProp<ViewStyle> = selected
+    ? { borderColor: colors.accent, borderWidth: 2 }
+    : undefined;
+  const plan = planLabelChip(label);
+  if (plan.kind === "single") {
+    return <ChipHalf half={plan.half} ring={ring} query={query} />;
+  }
+  return (
+    <View
+      style={[
+        {
+          flexDirection: "row",
+          alignSelf: "flex-start",
+          borderRadius: resolveRadius("pill"),
+        },
+        CHIP_WIDTH_STYLE,
+        ring,
+      ]}
+    >
+      <ChipHalf half={plan.scope} side="scope" query={query} />
+      <ChipHalf half={plan.value} side="value" query={query} />
+    </View>
+  );
+}
+
+/** Wrapping row the label lists share; a caller only supplies layout deltas. */
+const CHIP_LIST_STYLE: ViewStyle = { flexDirection: "row", flexWrap: "wrap", gap: 4 };
+
+/**
+ * The single render path for a list of labels. Surfaces supply only layout, so
+ * no site maps its own chips and colors always flow through `planLabelChip`.
+ */
+export function LabelChipList({
+  labels,
+  style,
+  query,
+}: {
+  labels: readonly ForgeLabel[];
+  style?: StyleProp<ViewStyle>;
+  /** Active search query; label names are highlighted when supplied. */
+  query?: string;
+}) {
+  if (labels.length === 0) return null;
+  return (
+    <View style={[CHIP_LIST_STYLE, style]}>
+      {labels.map((label) => (
+        <LabelChip key={label.name} label={label} query={query} />
+      ))}
+    </View>
+  );
+}

package/client/linkifier.tsx

@@ -0,0 +1,280 @@
+import React from "react";
+import { Linking, Pressable, StyleSheet, Text, View } from "react-native";
+import { z } from "zod";
+import type {
+  PluginTimelineItemProps,
+  PluginTimelineTransformerContribution,
+  PluginTimelineRendererContribution,
+} from "@getpaseo/plugin/client";
+import type { PluginTheme } from "@getpaseo/plugin";
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { ForgeIcon, copyToClipboard } from "paseo-plugin-helper/client";
+import {
+  classifyForgeLink,
+  classifyForgeUrl,
+  extractBareForgeIssueUrls,
+  parseMarkdownLite,
+  type ForgeRepoIdentity,
+  type ForgeIssueLink,
+  type MarkdownLiteSpan,
+} from "../shared/issues.js";
+import { useActiveForgeIdentityForAgent } from "./active-forge.js";
+import { FOREIGN_LINK_HINT, ForeignInlineMark, ForeignLinkBadge } from "./foreign-link.js";
+
+const ForgeIssueLinkSchema = z.object({
+  text: z.string(),
+  links: z.array(
+    z.object({
+      host: z.string(),
+      owner: z.string(),
+      repo: z.string(),
+      number: z.number(),
+      commentId: z.number().optional(),
+      url: z.string(),
+    }),
+  ),
+});
+type ForgeIssueLinkData = z.infer<typeof ForgeIssueLinkSchema>;
+
+function transformTextItem<T extends { text: string }>(item: T) {
+  const links = extractBareForgeIssueUrls(item.text);
+  if (links.length === 0) return undefined;
+  return {
+    items: [
+      {
+        type: "plugin" as const,
+        kind: "forge-issue-link",
+        version: 1,
+        data: {
+          text: item.text,
+          links: links.map((link) => ({
+            host: link.host,
+            owner: link.owner,
+            repo: link.repo,
+            number: link.number,
+            ...(link.commentId != null ? { commentId: link.commentId } : {}),
+            url: link.url,
+          })),
+        },
+      },
+    ],
+  };
+}
+
+/**
+ * Timeline linkifier: any chat message carrying forge issue URLs gets a
+ * compact link card alongside it. Both user and assistant messages are
+ * covered; messages without issue URLs pass through untouched.
+ */
+export const forgeLinkUserTransformer: PluginTimelineTransformerContribution<"user_message"> = {
+  id: "forge-issue-link-user",
+  query: { itemType: "user_message" },
+  transform({ item }) {
+    return transformTextItem(item);
+  },
+};
+
+export const forgeLinkAssistantTransformer: PluginTimelineTransformerContribution<"assistant_message"> = {
+  id: "forge-issue-link-assistant",
+  query: { itemType: "assistant_message" },
+  transform({ item }) {
+    return transformTextItem(item);
+  },
+};
+
+function IssueLinkRow({
+  theme,
+  link,
+  foreign,
+}: {
+  theme: PluginTheme;
+  link: ForgeIssueLink;
+  foreign: boolean;
+}) {
+  const open = () => {
+    Linking.openURL(link.url).catch(() => {});
+  };
+  const copy = () => {
+    copyToClipboard(link.url).catch(() => {});
+  };
+  return (
+    <View style={styles.row}>
+      <ForgeIcon host={link.host} size={13} color={theme.colors.accent} />
+      <Pressable
+        style={styles.linkBody}
+        onPress={open}
+        hitSlop={8}
+        accessibilityRole="link"
+        accessibilityLabel={
+          foreign
+            ? `${link.owner}/${link.repo}#${link.number} on ${link.host} — ${FOREIGN_LINK_HINT}`
+            : undefined
+        }
+      >
+        <Text style={[styles.linkText, { color: theme.colors.accent }]}>
+          {link.owner}/{link.repo}#{link.number}
+        </Text>
+        <Text style={[styles.hostText, { color: theme.colors.foregroundMuted }]}>
+          {link.host}
+        </Text>
+      </Pressable>
+      {foreign ? <ForeignLinkBadge /> : null}
+      <Pressable accessibilityRole="button" accessibilityLabel="Copy issue link" onPress={copy} hitSlop={10}>
+        <Text style={[styles.copyText, { color: theme.colors.foregroundMuted }]}>⧉</Text>
+      </Pressable>
+    </View>
+  );
+}
+
+function FormattedSpans({
+  theme,
+  spans,
+  activeForge,
+}: {
+  theme: PluginTheme;
+  spans: MarkdownLiteSpan[];
+  activeForge: ForgeRepoIdentity | null;
+}) {
+  return (
+    <Text style={[styles.bodyText, { color: theme.colors.foreground }]}>
+      {spans.map((span, index) => {
+        if (span.kind === "link") {
+          const foreign = classifyForgeUrl(span.url, activeForge) === "foreign";
+          return (
+            <Text
+              key={index}
+              style={{ color: theme.colors.accent, fontWeight: "600" }}
+              onPress={() => Linking.openURL(span.url).catch(() => {})}
+            >
+              {span.text}
+              {foreign ? <ForeignInlineMark color={theme.colors.statusWarning} /> : null}
+            </Text>
+          );
+        }
+        if (span.kind === "code") {
+          return (
+            <Text key={index} style={{ fontFamily: "monospace" }}>
+              {span.text}
+            </Text>
+          );
+        }
+        if (span.kind === "bold") {
+          return (
+            <Text key={index} style={{ fontWeight: "700" }}>
+              {span.text}
+            </Text>
+          );
+        }
+        if (span.kind === "italic") {
+          return (
+            <Text key={index} style={{ fontStyle: "italic" }}>
+              {span.text}
+            </Text>
+          );
+        }
+        return <Text key={index}>{span.text}</Text>;
+      })}
+    </Text>
+  );
+}
+
+function ForgeIssueLinks({ theme, item, agentId }: PluginTimelineItemProps<ForgeIssueLinkData>) {
+  const activeForge = useActiveForgeIdentityForAgent(agentId);
+  const blocks = parseMarkdownLite(item.data.text);
+  return (
+    <View style={styles.card}>
+      {blocks.map((block, index) => {
+        if (block.kind === "code") {
+          return (
+            <Text
+              key={index}
+              selectable
+              style={[styles.bodyText, { color: theme.colors.foregroundMuted, fontFamily: "monospace" }]}
+            >
+              {block.text}
+            </Text>
+          );
+        }
+        if (block.kind === "heading") {
+          return <FormattedSpans key={index} theme={theme} spans={block.spans} activeForge={activeForge} />;
+        }
+        if (block.kind === "list") {
+          return (
+            <View key={index} style={{ gap: 2 }}>
+              {block.items.map((spans, itemIndex) => (
+                <View key={itemIndex} style={{ flexDirection: "row", gap: 6 }}>
+                  <Text style={[styles.bodyText, { color: theme.colors.foregroundMuted }]}>
+                    {block.ordered ? `${itemIndex + 1}.` : "•"}
+                  </Text>
+                  <View style={{ flex: 1 }}>
+                    <FormattedSpans theme={theme} spans={spans} activeForge={activeForge} />
+                  </View>
+                </View>
+              ))}
+            </View>
+          );
+        }
+        return <FormattedSpans key={index} theme={theme} spans={block.spans} activeForge={activeForge} />;
+      })}
+      <View style={styles.header}>
+        <Icon name="GitPullRequest" size={13} color={theme.colors.foregroundMuted} />
+        <Text style={[styles.headerText, { color: theme.colors.foregroundMuted }]}>
+          {item.data.links.length === 1 ? "Linked issue" : `${item.data.links.length} linked issues`}
+        </Text>
+      </View>
+      {item.data.links.map((link) => (
+        <IssueLinkRow
+          key={`${link.host}/${link.owner}/${link.repo}#${link.number}`}
+          theme={theme}
+          link={link}
+          foreign={classifyForgeLink(link, activeForge) === "foreign"}
+        />
+      ))}
+    </View>
+  );
+}
+
+export const forgeLinkRenderer: PluginTimelineRendererContribution<typeof ForgeIssueLinkSchema> = {
+  kind: "forge-issue-link",
+  version: 1,
+  schema: ForgeIssueLinkSchema,
+  Component: ForgeIssueLinks,
+};
+
+const styles = StyleSheet.create({
+  card: {
+    paddingVertical: 4,
+    gap: 4,
+  },
+  bodyText: {
+    fontSize: 13,
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 6,
+  },
+  headerText: {
+    fontSize: 11,
+    fontWeight: "600",
+  },
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8,
+  },
+  linkBody: {
+    flex: 1,
+    gap: 1,
+  },
+  linkText: {
+    fontSize: 13,
+    fontWeight: "600",
+  },
+  hostText: {
+    fontSize: 11,
+  },
+  copyText: {
+    fontSize: 14,
+  },
+});

package/client/pill-label.ts

@@ -0,0 +1,183 @@
+import {
+  activeForgeForDirectory,
+  displayNameForDirectory,
+  forgeSettingsContract,
+  formatIssueCountLabel,
+  openIssuesContract,
+  workspaceNameKey,
+  type ForgeSettings,
+  type OpenIssuesOutput,
+} from "../shared/issues.js";
+
+export interface ForgePillLabelInput {
+  /** Workspace display name (explicit label, else the resolved repo). */
+  displayName?: string | null;
+  /** Open issue count, or null/undefined while unknown. */
+  count?: number | null;
+  /** True while the first fetch is still in flight. */
+  loading?: boolean;
+}
+
+/**
+ * Composer pill label for a workspace's open issues.
+ *
+ * Resolution order: the workspace display name while the count is unknown
+ * (`tea`), `name · N` once it resolves (`tea · 3`), the bare count when no
+ * display name exists (`3 issues`), and an ellipsis while nothing is known.
+ * Never a placeholder literal: the old `iss` regression came from a bare
+ * fallback leaking into the host-rendered button label.
+ */
+export function forgePillLabel(input: ForgePillLabelInput = {}): string {
+  if (input.loading) return "...";
+  const displayName =
+    typeof input.displayName === "string" && input.displayName.trim()
+      ? input.displayName.trim()
+      : null;
+  const count = input.count ?? null;
+  if (count == null) return displayName ?? "...";
+  return displayName ? `${displayName} · ${count}` : formatIssueCountLabel(count);
+}
+
+/** Workspace coordinates the label resolver needs, mirroring the plugin snapshot. */
+export interface ForgePillWorkspace {
+  directory?: string;
+  projectRootPath?: string;
+}
+
+export type ForgePillRpc = (contract: unknown, input: unknown) => Promise<unknown>;
+
+/**
+ * Host-provided capabilities the pill label needs outside React. On
+ * button-shaped hosts (Paseo 0.8+) `renderPill` never mounts, so the label
+ * resolver must fetch its own data instead of reading a hook-populated cache.
+ */
+export interface ForgePillRuntime {
+  rpc: ForgePillRpc;
+  resolveWorkspace: (workspaceId: string) => Promise<ForgePillWorkspace | null>;
+  /** Injectable clock so tests can age the caches deterministically. */
+  now?: () => number;
+}
+
+export interface ForgePillContext {
+  agentId: string;
+  workspaceId: string;
+}
+
+export interface ForgeLabelResolver {
+  /** Resolves the live pill label, refreshing the count when stale. */
+  resolve(ctx: ForgePillContext): Promise<string>;
+}
+
+interface CachedCount {
+  directory?: string;
+  count: number | null;
+  displayName: string | null;
+  at: number;
+}
+
+const PILL_DATA_TTL_MS = 15000;
+const SETTINGS_TTL_MS = 30000;
+const WORKSPACE_TTL_MS = 30000;
+
+/**
+ * Builds a self-contained composer pill label resolver.
+ *
+ * On button-shaped hosts the helper resolves the label once at registration and
+ * then every refresh interval, so this resolver owns its data: it resolves the
+ * workspace directory from the host, reads the plugin settings, and queries the
+ * open-issues contract itself. Counts are cached per workspace with a TTL and a
+ * shared in-flight guard so multiple agent pills in one workspace stay cheap.
+ * Nothing here ever returns a placeholder literal — failures fall back to the
+ * workspace name or an ellipsis.
+ */
+export function createForgeLabelResolver(runtime: ForgePillRuntime): ForgeLabelResolver {
+  const now = runtime.now ?? (() => Date.now());
+  const counts = new Map<string, CachedCount>();
+  const countInflight = new Map<string, Promise<void>>();
+  const workspaces = new Map<string, { info: ForgePillWorkspace | null; at: number }>();
+  const workspaceInflight = new Map<string, Promise<ForgePillWorkspace | null>>();
+  let settingsCache: { value: ForgeSettings; at: number } | null = null;
+  let settingsInflight: Promise<ForgeSettings> | null = null;
+
+  function readCachedLabel(ctx: ForgePillContext): string {
+    const cached = counts.get(ctx.workspaceId);
+    return forgePillLabel({ displayName: cached?.displayName ?? null, count: cached?.count ?? null });
+  }
+
+  async function resolveWorkspace(workspaceId: string): Promise<ForgePillWorkspace | null> {
+    const cached = workspaces.get(workspaceId);
+    if (cached && now() - cached.at < WORKSPACE_TTL_MS) return cached.info;
+    let inflight = workspaceInflight.get(workspaceId);
+    if (!inflight) {
+      inflight = runtime
+        .resolveWorkspace(workspaceId)
+        .then((info) => {
+          workspaces.set(workspaceId, { info, at: now() });
+          return info;
+        })
+        .catch(() => null)
+        .finally(() => {
+          workspaceInflight.delete(workspaceId);
+        });
+      workspaceInflight.set(workspaceId, inflight);
+    }
+    return inflight;
+  }
+
+  async function resolveSettings(): Promise<ForgeSettings> {
+    if (settingsCache && now() - settingsCache.at < SETTINGS_TTL_MS) return settingsCache.value;
+    if (!settingsInflight) {
+      settingsInflight = runtime
+        .rpc(forgeSettingsContract.get, {})
+        .then((value) => value as ForgeSettings)
+        .catch(() => forgeSettingsContract.defaultSettings)
+        .then((value) => {
+          settingsCache = { value, at: now() };
+          return value;
+        })
+        .finally(() => {
+          settingsInflight = null;
+        });
+    }
+    return settingsInflight;
+  }
+
+  async function refresh(ctx: ForgePillContext): Promise<void> {
+    const workspace = await resolveWorkspace(ctx.workspaceId);
+    const directory = workspace?.directory;
+    const cached = counts.get(ctx.workspaceId);
+    if (cached && cached.directory === directory && now() - cached.at < PILL_DATA_TTL_MS) return;
+
+    const key = directory ?? ctx.workspaceId;
+    let inflight = countInflight.get(key);
+    if (!inflight) {
+      inflight = (async () => {
+        const settings = await resolveSettings();
+        const remoteUrl = activeForgeForDirectory(settings, directory) ?? undefined;
+        const data = (await runtime.rpc(openIssuesContract, {
+          directory: directory ?? undefined,
+          remoteUrl: remoteUrl || undefined,
+        })) as OpenIssuesOutput | undefined;
+        const count = data && !data.error ? (data.openIssueCount ?? data.issues.length) : null;
+        const nameKey = workspaceNameKey(directory, workspace?.projectRootPath);
+        const displayName = displayNameForDirectory(settings, nameKey, data?.repo);
+        counts.set(ctx.workspaceId, { directory, count, displayName, at: now() });
+      })()
+        .catch(() => {
+          // Keep the last cached label when the forge is unreachable.
+        })
+        .finally(() => {
+          countInflight.delete(key);
+        });
+      countInflight.set(key, inflight);
+    }
+    await inflight;
+  }
+
+  return {
+    resolve: async (ctx) => {
+      await refresh(ctx);
+      return readCachedLabel(ctx);
+    },
+  };
+}

package/client/vendor/paseo-plugin-helper/command-center.ts

@@ -0,0 +1,43 @@
+import type { PluginCleanup } from "./host";
+
+/**
+ * Structural registrar interface satisfied by both Paseo v0.7 PluginContext
+ * and Paseo v0.8 PluginClientContext.
+ */
+export interface CommandCenterItemRegistrar {
+  addCommandCenterItem(contribution: any): any;
+}
+
+export type CommandCenterContext = "global" | "workspace" | "agent";
+
+/**
+ * Capabilities the host passes to a command-center item's `onSelect`. Mirrors
+ * the subset of `PluginCommandCapabilities` the helper needs; the real host
+ * context carries additional fields (paseo, rpc, workspace, agent) that a
+ * handler may read off its own typed contribution.
+ */
+export interface CommandCenterCapabilities {
+  openSurface(id: string): void;
+  openSettings(id: string): void;
+}
+
+export interface CommandCenterItemContribution {
+  id: string;
+  title: string;
+  icon: string;
+  keywords?: readonly string[];
+  context: CommandCenterContext;
+  onSelect(context: CommandCenterCapabilities): void | Promise<void>;
+}
+
+/**
+ * Registers a command-center palette item — the entry the host Ctrl+K command
+ * center lists. Thin pass-through that keeps plugins on the helper seam and
+ * works with both Paseo v0.7 PluginContext and Paseo v0.8 PluginClientContext.
+ */
+export function registerCommandCenterItem(
+  plugin: CommandCenterItemRegistrar,
+  contribution: CommandCenterItemContribution,
+): PluginCleanup {
+  return plugin.addCommandCenterItem(contribution);
+}