@yannelli/paseo-linear-plugin 0.1.0 → 0.4.0

package/client/launch-fields.tsx

@@ -0,0 +1,152 @@
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { type ReactNode, useCallback, useMemo } from "react";
+import { Pressable, type PressableStateCallbackType, Switch, Text, View } from "react-native";
+import { type Theme, usePressableStyle } from "./ui";
+
+// Matches the controls under Paseo's agent composer: an icon, the value, and a chevron.
+export function Chip(props: {
+  theme: Theme;
+  icon: ReactNode;
+  value: string;
+  accessibilityLabel: string;
+  disabled?: boolean;
+  onPress(): void;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(() => {
+    const idle = {
+      height: 28,
+      paddingHorizontal: 8,
+      borderRadius: 16,
+      flexDirection: "row" as const,
+      alignItems: "center" as const,
+      gap: 4,
+      minWidth: 0,
+      maxWidth: 260,
+      opacity: props.disabled ? 0.5 : 1,
+    };
+    return {
+      idle,
+      hovered: { ...idle, backgroundColor: colors.surface2 },
+      pressed: { ...idle, backgroundColor: colors.surface0 },
+      icon: {
+        width: 16,
+        height: 16,
+        alignItems: "center" as const,
+        justifyContent: "center" as const,
+      },
+      value: { color: colors.foregroundMuted, fontSize: 14, flexShrink: 1, minWidth: 0 },
+      chevron: { transform: [{ translateY: 1 }] },
+    };
+  }, [colors, props.disabled]);
+  const style = useCallback(
+    (state: PressableStateCallbackType) =>
+      state.pressed
+        ? styles.pressed
+        : (state as { hovered?: boolean }).hovered
+          ? styles.hovered
+          : styles.idle,
+    [styles],
+  );
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={props.accessibilityLabel}
+      disabled={props.disabled}
+      onPress={props.onPress}
+      style={style}
+    >
+      <View style={styles.icon}>{props.icon}</View>
+      <Text numberOfLines={1} style={styles.value}>
+        {props.value}
+      </Text>
+      <View style={styles.chevron}>
+        <Icon name="ChevronDown" size={14} color={colors.foregroundMuted} />
+      </View>
+    </Pressable>
+  );
+}
+
+export function Field(props: {
+  theme: Theme;
+  label: string;
+  icon: string;
+  value: string;
+  detail?: string;
+  onPress(): void;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(() => {
+    const idle = {
+      minHeight: 44,
+      paddingHorizontal: 12,
+      paddingVertical: 8,
+      borderRadius: 8,
+      borderWidth: 1,
+      borderColor: colors.border,
+      flexDirection: "row" as const,
+      alignItems: "center" as const,
+      gap: 10,
+      backgroundColor: colors.surface1,
+    };
+    return {
+      idle,
+      active: { ...idle, backgroundColor: colors.surface2 },
+      label: { color: colors.foregroundMuted, fontSize: 13, width: 64 },
+      body: { flex: 1, minWidth: 0 },
+      value: { color: colors.foreground, fontSize: 14 },
+      detail: { color: colors.foregroundMuted, fontSize: 12 },
+    };
+  }, [colors]);
+  const style = usePressableStyle(styles.idle, styles.active);
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={`${props.label}: ${props.value}`}
+      onPress={props.onPress}
+      style={style}
+    >
+      <Icon name={props.icon} size={16} color={colors.foregroundMuted} />
+      <Text style={styles.label}>{props.label}</Text>
+      <View style={styles.body}>
+        <Text numberOfLines={1} style={styles.value}>
+          {props.value}
+        </Text>
+        {props.detail ? (
+          <Text numberOfLines={1} style={styles.detail}>
+            {props.detail}
+          </Text>
+        ) : null}
+      </View>
+      <Icon name="ChevronDown" size={14} color={colors.foregroundMuted} />
+    </Pressable>
+  );
+}
+
+export function Toggle(props: {
+  theme: Theme;
+  label: string;
+  value: boolean;
+  onChange(value: boolean): void;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(
+    () => ({
+      row: { minHeight: 36, flexDirection: "row" as const, alignItems: "center" as const, gap: 10 },
+      label: { flex: 1, color: colors.foreground, fontSize: 14 },
+      track: { true: colors.accent, false: colors.surface2 },
+    }),
+    [colors],
+  );
+  return (
+    <View style={styles.row}>
+      <Text style={styles.label}>{props.label}</Text>
+      <Switch
+        accessibilityLabel={props.label}
+        value={props.value}
+        onValueChange={props.onChange}
+        trackColor={styles.track}
+      />
+    </View>
+  );
+}

package/client/launch-plan.ts

@@ -0,0 +1,227 @@
+import { usePaseo, useRpc } from "@getpaseo/plugin/client";
+import { useMutation } from "@tanstack/react-query";
+import {
+  attachIssueCardRpc,
+  type IssueDetail,
+  type IssuePatch,
+  updateIssueRpc,
+  type WorkflowState,
+} from "../shared/linear";
+import { AGENT_LABELS, agentTitle } from "../shared/prompts";
+import type { AgentAction, Isolation, LinearSettings } from "../shared/settings";
+import { type AgentSelection, agentConfig } from "./agent-options";
+import type { PaseoProjectOption } from "./queries";
+import { errorMessage } from "./ui";
+
+export type Placement = "worktree" | "pull-request" | "branch" | "agent-workspace" | "workspace";
+
+export interface PlacementOption {
+  value: Placement;
+  label: string;
+  detail: string;
+}
+
+export interface TargetWorkspace {
+  id: string;
+  projectId: string;
+  name: string;
+}
+
+const lastProjectByTeam = new Map<string, string>();
+
+export function pullRequestNumber(issue: IssueDetail): number | null {
+  for (const attachment of issue.attachments) {
+    const match = /github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/.exec(attachment.url);
+    if (match?.[1]) return Number(match[1]);
+  }
+  return null;
+}
+
+export function defaultProjectId(input: {
+  target: TargetWorkspace | null;
+  teamId: string;
+  settings: LinearSettings;
+  projects: readonly PaseoProjectOption[] | undefined;
+}): string | null {
+  if (input.target) return input.target.projectId;
+  const remembered = lastProjectByTeam.get(input.teamId);
+  if (remembered) return remembered;
+  const mapped = input.settings.projects.find((entry) => entry.teamIds.includes(input.teamId));
+  return mapped?.projectId ?? input.projects?.[0]?.projectId ?? null;
+}
+
+export function placementOptions(input: {
+  action: AgentAction;
+  prNumber: number | null;
+  project: PaseoProjectOption | null;
+  branchName: string;
+  target: TargetWorkspace | null;
+  agentWorkspace: TargetWorkspace | null;
+}): PlacementOption[] {
+  const options: PlacementOption[] = [];
+  const git = input.project?.kind === "git";
+  const review = input.action === "review";
+  if (review && git && input.prNumber !== null) {
+    options.push({
+      value: "pull-request",
+      label: `Check out PR #${input.prNumber}`,
+      detail: "New worktree on the pull request branch",
+    });
+  }
+  if (input.agentWorkspace) {
+    options.push({
+      value: "agent-workspace",
+      label: review ? "Implementation workspace" : "Existing agent workspace",
+      detail: input.agentWorkspace.name,
+    });
+  }
+  if (git) {
+    options.push(
+      review
+        ? { value: "branch", label: "Check out issue branch", detail: input.branchName }
+        : { value: "worktree", label: "New worktree", detail: input.branchName },
+    );
+  }
+  const here = input.target !== null && input.target.projectId === input.project?.projectId;
+  options.push(
+    here && input.target
+      ? { value: "workspace", label: "This workspace", detail: input.target.name }
+      : { value: "workspace", label: "Project folder", detail: input.project?.rootPath ?? "" },
+  );
+  return options;
+}
+
+// Reviews look at existing work: the pull request, then the implementing agent's workspace.
+function preferredPlacement(action: AgentAction, isolation: Isolation): Placement[] {
+  if (action === "review") return ["pull-request", "agent-workspace", "workspace"];
+  return isolation === "worktree" ? ["worktree", "workspace"] : ["workspace"];
+}
+
+export function resolvePlacement(
+  options: readonly PlacementOption[],
+  choice: Placement | null,
+  action: AgentAction,
+  isolation: Isolation,
+): PlacementOption | null {
+  const wanted = choice ? [choice] : preferredPlacement(action, isolation);
+  for (const value of wanted) {
+    const match = options.find((option) => option.value === value);
+    if (match) return match;
+  }
+  return options[0] ?? null;
+}
+
+export function linearPatch(input: {
+  started: WorkflowState | null;
+  moveToStarted: boolean;
+  viewerId: string | null;
+  assignToMe: boolean;
+}): IssuePatch {
+  const patch: IssuePatch = {};
+  if (input.moveToStarted && input.started) patch.stateId = input.started.id;
+  if (input.assignToMe && input.viewerId) patch.assigneeId = input.viewerId;
+  return patch;
+}
+
+export interface LaunchRequest {
+  action: AgentAction;
+  issue: IssueDetail;
+  project: PaseoProjectOption;
+  agent: AgentSelection;
+  placement: Placement;
+  prNumber: number | null;
+  target: TargetWorkspace | null;
+  agentWorkspace: TargetWorkspace | null;
+  prompt: string;
+  patch: IssuePatch;
+  started: WorkflowState | null;
+  /** The Paseo project whose Linear key loaded the issue. */
+  keyScope: string | null;
+}
+
+type Paseo = ReturnType<typeof usePaseo>;
+
+async function openWorkspace(paseo: Paseo, request: LaunchRequest) {
+  const { issue, project } = request;
+  if (request.placement === "worktree") {
+    return paseo.workspaces.create({
+      title: `${issue.identifier} ${issue.title}`,
+      source: {
+        kind: "worktree",
+        cwd: project.rootPath,
+        projectId: project.projectId,
+        action: "branch-off",
+        branchName: issue.branchName,
+      },
+    });
+  }
+  if (request.placement === "pull-request" && request.prNumber !== null) {
+    return paseo.workspaces.create({
+      title: `Review ${issue.identifier}`,
+      source: {
+        kind: "worktree",
+        cwd: project.rootPath,
+        projectId: project.projectId,
+        action: "checkout",
+        checkoutSource: { kind: "change_request", forge: "github", number: request.prNumber },
+      },
+    });
+  }
+  if (request.placement === "branch") {
+    return paseo.workspaces.create({
+      title: `Review ${issue.identifier}`,
+      source: {
+        kind: "worktree",
+        cwd: project.rootPath,
+        projectId: project.projectId,
+        action: "checkout",
+        refName: issue.branchName,
+      },
+    });
+  }
+  if (request.placement === "agent-workspace" && request.agentWorkspace) {
+    return paseo.workspaces.ref(request.agentWorkspace.id);
+  }
+  if (request.target && request.target.projectId === project.projectId) {
+    return paseo.workspaces.ref(request.target.id);
+  }
+  return paseo.workspaces.open(project.rootPath);
+}
+
+export function useLaunchAgent() {
+  const paseo = usePaseo();
+  const updateIssue = useRpc(updateIssueRpc);
+  const attachCard = useRpc(attachIssueCardRpc);
+  return useMutation({
+    mutationFn: async (request: LaunchRequest) => {
+      const { issue, action } = request;
+      const workspace = await openWorkspace(paseo, request);
+      const agent = await workspace.agents.create({
+        config: agentConfig(request.agent),
+        title: agentTitle(action, issue),
+        prompt: request.prompt,
+        labels: { [AGENT_LABELS.issue]: issue.identifier, [AGENT_LABELS.action]: action },
+      });
+      lastProjectByTeam.set(issue.team.id, request.project.projectId);
+      let warning: string | null = null;
+      if (Object.keys(request.patch).length > 0) {
+        try {
+          await updateIssue({ id: issue.id, patch: request.patch, projectId: request.keyScope });
+        } catch (error) {
+          warning = errorMessage(error);
+        }
+      }
+      const state = request.patch.stateId && request.started ? request.started : issue.state;
+      const card = {
+        identifier: issue.identifier,
+        title: issue.title,
+        url: issue.url,
+        stateName: state.name,
+        stateColor: state.color,
+        action,
+      };
+      void attachCard({ agentId: agent.id, card }).catch(() => undefined);
+      return { agentId: agent.id, warning };
+    },
+  });
+}