@yannelli/paseo-linear-plugin 1.0.1 → 1.1.0-beta.1

package/client/settings-live.tsx

@@ -0,0 +1,145 @@
+import { type PluginSurfaceProps, useSettings } from "@getpaseo/plugin/client";
+import {
+  SettingsCard,
+  SettingsSection,
+  SettingsSelect,
+  SettingsSwitch,
+} from "@getpaseo/plugin/client/ui";
+import { useCallback, useMemo } from "react";
+import { View } from "react-native";
+import {
+  type LinearSettings,
+  type LiveView,
+  linearSettings,
+  type MappingMode,
+} from "../shared/settings";
+import { useProviders } from "./queries";
+import { type ReadySettings, SaveBar, SettingsGate, useSettingsDraft } from "./settings-fields";
+import type { Theme } from "./ui";
+
+const MAPPING_OPTIONS: readonly { label: string; value: MappingMode }[] = [
+  { label: "Ticket text: free, rough", value: "semantic" },
+  { label: "Explore agent: reads the repo first", value: "explore" },
+];
+const VIEW_OPTIONS: readonly { label: string; value: LiveView }[] = [
+  { label: "Map: files grouped by folder", value: "map" },
+  { label: "Graph: issue, files, and agents as connected nodes", value: "graph" },
+];
+const SAME_AGENT = "";
+const MODEL_DEFAULT = "";
+
+export function LiveSettings({ theme }: PluginSurfaceProps) {
+  const settings = useSettings(linearSettings);
+  const render = useCallback(
+    (ready: ReadySettings) => <LiveEditor theme={theme} settings={ready} />,
+    [theme],
+  );
+  return (
+    <SettingsGate theme={theme} title="Live" settings={settings}>
+      {render}
+    </SettingsGate>
+  );
+}
+
+type Live = LinearSettings["live"];
+
+function LiveEditor({ theme, settings }: { theme: Theme; settings: ReadySettings }) {
+  const { values, dirty, edit, save, discard } = useSettingsDraft(settings);
+  const providers = useProviders();
+  const live = values.live;
+  const change = useCallback(
+    (patch: Partial<Live>) => edit((current) => ({ ...current, live: { ...current.live, ...patch } })),
+    [edit],
+  );
+  const agentOptions = useMemo(() => {
+    const options = [{ label: "Same agent as the implementer", value: SAME_AGENT }];
+    for (const agent of providers.data ?? []) {
+      for (const model of agent.models) {
+        options.push({ label: `${agent.label} · ${model.label}`, value: `${agent.id}/${model.id}` });
+      }
+    }
+    if (live.exploreProvider && !options.some((option) => option.value === live.exploreProvider)) {
+      options.push({ label: `${live.exploreProvider} · not on this host`, value: live.exploreProvider });
+    }
+    return options;
+  }, [providers.data, live.exploreProvider]);
+  // Efforts of the chosen model, such as Low to Max, with its default first.
+  const effortOptions = useMemo(() => {
+    const [agentId, ...rest] = live.exploreProvider.split("/");
+    const modelId = rest.join("/");
+    const model = providers.data
+      ?.find((agent) => agent.id === agentId)
+      ?.models.find((entry) => entry.id === modelId);
+    if (!model || model.efforts.length === 0) return null;
+    const fallback = model.efforts.find((effort) => effort.id === model.defaultEffortId);
+    return [
+      { label: fallback ? `Model default: ${fallback.label}` : "Model default", value: MODEL_DEFAULT },
+      ...model.efforts.map((effort) => ({ label: effort.label, value: effort.id })),
+    ];
+  }, [providers.data, live.exploreProvider]);
+
+  return (
+    <View>
+      <SettingsSection title="Linear Live">
+        <SettingsCard>
+          <SettingsSwitch
+            label="Show Linear Live"
+            hint="Track agents started from an issue: sub-issues, todos, and the files they touch."
+            value={live.enabled}
+            onValueChange={(enabled) => change({ enabled })}
+          />
+          <SettingsSelect
+            label="Map files with"
+            hint="Ticket text finds paths named in the issue. The explore agent reads the repository first, and the implement agent starts when the map is ready. It costs provider usage."
+            value={live.mapping}
+            options={MAPPING_OPTIONS}
+            onValueChange={(mapping) => change({ mapping })}
+            disabled={!live.enabled}
+          />
+          <SettingsSelect
+            label="Show files as"
+            hint="The view Linear Live opens with. Switch it in the panel at any time."
+            value={live.view}
+            options={VIEW_OPTIONS}
+            onValueChange={(view) => change({ view })}
+            disabled={!live.enabled}
+          />
+          <SettingsSelect
+            label="Explore and setup agent"
+            hint="It may only read and search the project folder. A faster, cheaper model is usually enough."
+            value={live.exploreProvider}
+            options={agentOptions}
+            onValueChange={(exploreProvider) => change({ exploreProvider, exploreEffort: MODEL_DEFAULT })}
+          />
+          {effortOptions ? (
+            <SettingsSelect
+              label="Explore and setup effort"
+              hint="How much the model thinks before it answers. Lower is faster and uses less of your plan."
+              value={effortOptions.some((option) => option.value === live.exploreEffort) ? live.exploreEffort : MODEL_DEFAULT}
+              options={effortOptions}
+              onValueChange={(exploreEffort) => change({ exploreEffort })}
+            />
+          ) : null}
+        </SettingsCard>
+      </SettingsSection>
+      <SettingsSection title="Linear status sync">
+        <SettingsCard>
+          <SettingsSwitch
+            label="Update Linear from agent todos"
+            hint="After each turn, a todo that starts with a sub-issue key moves that sub-issue forward: In Progress, then Done. The parent moves to In Review when every sub-issue is Done. Statuses never move back."
+            value={live.syncTodos}
+            onValueChange={(syncTodos) => change({ syncTodos })}
+          />
+        </SettingsCard>
+      </SettingsSection>
+      <SaveBar
+        theme={theme}
+        dirty={dirty}
+        saving={settings.saving}
+        error={settings.saveError}
+        onSave={() => void save()}
+        onDiscard={discard}
+      />
+    </View>
+  );
+}

package/client/settings-projects.tsx

@@ -21,6 +21,8 @@ import {
   upsertProject,
 } from "../shared/settings";
 import { effectiveKeyScope, KeyScopeProvider } from "./key-scope";
+import { ProjectSetup } from "./project-init";
+import { AccessSection } from "./settings-access";
 import { type PaseoProjectOption, useAuthStatus, useCatalog, useProjects } from "./queries";
 import {
   MultilineField,
@@ -120,6 +122,12 @@ function ProjectEditor({ theme, settings }: { theme: Theme; settings: ReadySetti
   }
   return (
     <View>
+      <AccessSection
+        access={values.access}
+        saved={settings.values.access}
+        projects={projects.data}
+        edit={edit}
+      />
       <SettingsSection title="Project">
         <SettingsCard>
           <SettingsSelect
@@ -132,6 +140,7 @@ function ProjectEditor({ theme, settings }: { theme: Theme; settings: ReadySetti
         </SettingsCard>
       </SettingsSection>
       <TeamsSection config={config} change={change} />
+      <ProjectSetup theme={theme} config={config} change={change} />
       <InstructionsSection theme={theme} config={config} change={change} />
       {AGENT_ACTIONS.map((action) => (
         <ActionSection key={action} theme={theme} action={action} config={config} change={change} />

package/client/tool-buttons.tsx

@@ -0,0 +1,68 @@
+import { Icon } from "@getpaseo/plugin/client/react-native";
+import { type ReactNode, useMemo } from "react";
+import { ActivityIndicator, Pressable, View } from "react-native";
+import { type Theme, usePressableStyle } from "./ui";
+
+// Small icon buttons for card toolbars: map actions and the graph's camera. A group draws them
+// in one bordered track, like the Map and Graph switch.
+
+export function ToolGroup({ theme, children }: { theme: Theme; children: ReactNode }) {
+  const { colors } = theme;
+  const style = useMemo(
+    () =>
+      ({
+        flexDirection: "row",
+        alignItems: "center",
+        padding: 2,
+        gap: 2,
+        borderRadius: 8,
+        borderWidth: 1,
+        borderColor: colors.border,
+        backgroundColor: colors.surface1,
+      }) as const,
+    [colors],
+  );
+  return <View style={style}>{children}</View>;
+}
+
+export function ToolButton(props: {
+  theme: Theme;
+  icon: string;
+  /** Read by screen readers and shown as the tooltip on web. */
+  label: string;
+  onPress(): void;
+  /** A toggle that is on. */
+  active?: boolean;
+  disabled?: boolean;
+  busy?: boolean;
+}) {
+  const { colors } = props.theme;
+  const styles = useMemo(() => {
+    const idle = {
+      width: 26,
+      height: 24,
+      borderRadius: 6,
+      alignItems: "center",
+      justifyContent: "center",
+      backgroundColor: props.active ? colors.surface2 : "transparent",
+      opacity: props.disabled ? 0.4 : 1,
+    } as const;
+    return { idle, hover: { ...idle, backgroundColor: colors.surface2 } };
+  }, [colors, props.active, props.disabled]);
+  const pressStyle = usePressableStyle(styles.idle, styles.hover);
+  const color = props.active ? colors.foreground : colors.foregroundMuted;
+  return (
+    <Pressable
+      accessibilityRole="button"
+      accessibilityLabel={props.label}
+      accessibilityState={{ selected: props.active === true, disabled: props.disabled === true }}
+      disabled={props.disabled || props.busy}
+      onPress={props.onPress}
+      hitSlop={4}
+      style={pressStyle}
+      {...({ title: props.label } as object)}
+    >
+      {props.busy ? <ActivityIndicator size="small" color={color} /> : <Icon name={props.icon} size={14} color={color} />}
+    </Pressable>
+  );
+}

package/client/web.ts

@@ -0,0 +1,45 @@
+import { Platform } from "react-native";
+
+// The only module that uses the DOM. React wheel listeners are passive, so they cannot keep
+// the page from scrolling while the wheel zooms the graph. Off the web each export does nothing.
+
+interface WheelEventLike {
+  deltaY: number;
+  deltaMode: number;
+  clientX: number;
+  clientY: number;
+  preventDefault(): void;
+}
+
+type WheelListener = (event: WheelEventLike) => void;
+
+interface ElementLike {
+  addEventListener(type: "wheel", listener: WheelListener, options: { passive: boolean }): void;
+  removeEventListener(type: "wheel", listener: WheelListener): void;
+  getBoundingClientRect(): { left: number; top: number };
+}
+
+function isElement(node: unknown): node is ElementLike {
+  if (typeof node !== "object" || node === null) return false;
+  const element = node as Partial<ElementLike>;
+  return typeof element.addEventListener === "function" && typeof element.getBoundingClientRect === "function";
+}
+
+const LINE = 16;
+const PAGE = 400;
+
+/** Calls onWheel with the point under the pointer and a zoom factor. Returns the cleanup. */
+export function listenWheel(
+  node: unknown,
+  onWheel: (point: { x: number; y: number }, factor: number) => void,
+): () => void {
+  if (Platform.OS !== "web" || !isElement(node)) return () => {};
+  const listener: WheelListener = (event) => {
+    event.preventDefault();
+    const rect = node.getBoundingClientRect();
+    const pixels = event.deltaY * (event.deltaMode === 1 ? LINE : event.deltaMode === 2 ? PAGE : 1);
+    onWheel({ x: event.clientX - rect.left, y: event.clientY - rect.top }, Math.exp(-pixels * 0.002));
+  };
+  node.addEventListener("wheel", listener, { passive: false });
+  return () => node.removeEventListener("wheel", listener);
+}

package/index.client.tsx

@@ -1,7 +1,11 @@
 import type { PluginClientContext } from "@getpaseo/plugin/client";
 import { LinearPanel, LinearScreen } from "./client/browser";
 import { openPluginScreen, registerScreen } from "./client/compat";
+import { gateAgentPanel } from "./client/access";
+import { LivePanel } from "./client/live-panel";
+import { contributeComposerPills } from "./client/pill";
 import { ConnectionSettings } from "./client/settings-connection";
+import { LiveSettings } from "./client/settings-live";
 import { ProjectSettings } from "./client/settings-projects";
 import { PromptSettings } from "./client/settings-prompts";
 import { focusIssue, panelScope, SCREEN_SCOPE, updateBrowser } from "./client/store";
@@ -11,6 +15,7 @@ import { ISSUE_CARD_KIND, IssueCardSchema, LINEAR_IDENTIFIER } from "./shared/li
 
 const SCREEN_ID = "linear";
 const PANEL_ID = "issues";
+const LIVE_PANEL_ID = "live";
 
 export default function contribute(client: PluginClientContext) {
   client.addAttachmentSource(issueAttachments);
@@ -40,6 +45,19 @@ export default function contribute(client: PluginClientContext) {
     icon: "MessageSquare",
     Component: PromptSettings,
   });
+  client.addWorkspacePanel({
+    id: LIVE_PANEL_ID,
+    title: "Linear Live",
+    icon: "Radar",
+    context: "agent",
+    Component: gateAgentPanel(LivePanel),
+  });
+  client.addSettingsScreen({
+    id: "live",
+    title: "Live",
+    icon: "Radar",
+    Component: LiveSettings,
+  });
   client.addSettingsScreen({
     id: "projects",
     title: "Projects",
@@ -77,6 +95,26 @@ export default function contribute(client: PluginClientContext) {
       openPanel(PANEL_ID);
     },
   });
+  client.addCommandCenterItem({
+    id: "open-live",
+    title: "Linear: Open Linear Live",
+    icon: "Radar",
+    keywords: ["linear", "live", "progress", "map"],
+    context: "agent",
+    onSelect({ openPanel }) {
+      openPanel(LIVE_PANEL_ID);
+    },
+  });
+  client.addCommandCenterItem({
+    id: "setup-project",
+    title: "Linear: Set up project prompts",
+    icon: "Sparkles",
+    keywords: ["linear", "init", "setup", "agents.md", "guidelines"],
+    context: "global",
+    onSelect({ openSettings }) {
+      openSettings("projects");
+    },
+  });
   client.addCommandCenterItem({
     id: "settings",
     title: "Linear: Settings",
@@ -107,5 +145,5 @@ export default function contribute(client: PluginClientContext) {
     schema: IssueCardSchema,
     Component: IssueCardRow,
   });
-  return () => {};
+  return contributeComposerPills(client);
 }

package/index.server.ts

@@ -1,12 +1,36 @@
+import path from "node:path";
 import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { registerAgentHooks } from "./server/agent-hooks";
+import { registerAgentTools } from "./server/agent-tools";
 import { createCredentialStore, defaultCredentialPath } from "./server/credentials";
 import { registerHandlers } from "./server/handlers";
-import { linearSettings } from "./shared/settings";
+import { registerInit } from "./server/init";
+import { registerLive } from "./server/live";
+import { createLaunchQueue, createMapStore } from "./server/stores";
+import { registerSync } from "./server/sync";
+import { accessRpc, type LinearSettings, linearSettings } from "./shared/settings";
 
 export default function contribute(server: PluginServerContext) {
-  server.registerSettings(linearSettings);
-  registerHandlers(server, {
-    credentials: createCredentialStore({ file: defaultCredentialPath() }),
+  const settings = server.registerSettings(linearSettings);
+  const readSettings = async (): Promise<LinearSettings | null> => {
+    const state = await settings.read();
+    return state.status === "ready" ? state.values : null;
+  };
+  const credentialPath = defaultCredentialPath();
+  const access = registerHandlers(server, {
+    credentials: createCredentialStore({ file: credentialPath }),
   });
-  return () => {};
+  const dataDirectory = path.dirname(credentialPath);
+  const maps = createMapStore(path.join(dataDirectory, "live-maps.json"));
+  const launches = createLaunchQueue(path.join(dataDirectory, "pending-launches.json"));
+  registerLive(server, { access, maps, launches, readSettings });
+  registerSync(server, { access, readSettings });
+  registerInit(server, { readSettings });
+  registerAgentHooks(server, dataDirectory);
+  const closeTools = registerAgentTools(server, { access, dataDirectory });
+  server.handle(accessRpc, async () => {
+    const values = await readSettings();
+    return values?.access ?? linearSettings.schema.parse({}).access;
+  });
+  return closeTools;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yannelli/paseo-linear-plugin",
-  "version": "1.0.1",
+  "version": "1.1.0-beta.1",
   "description": "Browse and triage Linear issues in Paseo and start agents from them",
   "license": "Apache-2.0",
   "type": "module",

package/server/agent-hooks.ts

@@ -0,0 +1,37 @@
+import { createHash } from "node:crypto";
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { agentHooksRpc, claudeHooks, hookPluginName, IDENTIFIER } from "../shared/agent-hooks";
+
+// Writes one Claude Code plugin folder per issue under the plugin's data folder. A launch passes
+// the folder to Claude with --plugin-dir. The name holds a hash of the hooks, so a later launch
+// never changes the hooks of a running agent. Resumed agents keep using it, so it stays.
+
+async function writeAtomic(file: string, text: string) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, text, { mode: 0o600 });
+  await rename(temporary, file);
+}
+
+export function registerAgentHooks(server: PluginServerContext, dataDirectory: string) {
+  server.handle(agentHooksRpc, async ({ issue, guidance }) => {
+    // The hooks run printf in a POSIX shell, which Windows hosts do not have.
+    if (process.platform === "win32" || !IDENTIFIER.test(issue.identifier)) return { pluginDir: null };
+    const hooks = claudeHooks(issue, guidance);
+    if (!hooks) return { pluginDir: null };
+    const text = `${JSON.stringify(hooks, null, 2)}\n`;
+    const hash = createHash("sha256").update(text).digest("hex").slice(0, 12);
+    const root = path.join(dataDirectory, "claude-hooks", `${issue.identifier.toUpperCase()}-${hash}`);
+    await mkdir(path.join(root, ".claude-plugin"), { recursive: true, mode: 0o700 });
+    await mkdir(path.join(root, "hooks"), { recursive: true, mode: 0o700 });
+    const manifest = {
+      name: hookPluginName(issue.identifier),
+      version: "1.0.0",
+      description: `Linear context for ${issue.identifier} from the Paseo Linear plugin`,
+    };
+    await writeAtomic(path.join(root, ".claude-plugin", "plugin.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    await writeAtomic(path.join(root, "hooks", "hooks.json"), text);
+    return { pluginDir: root };
+  });
+}