@alasano/pi-linear 0.1.1 → 0.3.0

package/extensions/renderers/teams.ts

@@ -0,0 +1,246 @@
+import {
+  type AgentToolResult,
+  type Theme,
+  type ToolRenderResultOptions,
+} from '@mariozechner/pi-coding-agent';
+import { Text } from '@mariozechner/pi-tui';
+import {
+  asString,
+  cleanOneLine,
+  expandedJson,
+  shouldShowJson,
+  jsonHint,
+  LinearListResultComponent,
+  renderLinearToolCall,
+  renderResponsiveTable,
+  toolOutputStyle,
+  truncate,
+  truncateLine,
+  type LinearToolRenderContext,
+  type TableColumn,
+  type ToolArgs,
+} from './common';
+
+type WorkflowStateLike = {
+  id?: string | null;
+  name?: string | null;
+  type?: string | null;
+};
+
+type TeamLike = {
+  id?: string | null;
+  key?: string | null;
+  name?: string | null;
+  description?: string | null;
+  color?: string | null;
+  icon?: string | null;
+  private?: boolean | null;
+  states?: { nodes?: WorkflowStateLike[] | null } | null;
+};
+
+type TeamResultDetails = {
+  team?: TeamLike | null;
+  teams?: TeamLike[];
+};
+
+const TEAM_LIST_PREVIEW_LIMIT = 20;
+const NAME_LIMIT = 90;
+const DESCRIPTION_LIMIT = 160;
+const TABLE_NAME_MIN_WIDTH = 24;
+const STATE_TYPE_ORDER = ['backlog', 'unstarted', 'started', 'completed', 'canceled', 'cancelled'];
+
+function teamDetails(result: AgentToolResult<any>): TeamResultDetails {
+  return (result.details ?? {}) as TeamResultDetails;
+}
+
+function teamName(team: TeamLike): string {
+  return truncate(cleanOneLine(asString(team.name) ?? '(unnamed team)'), NAME_LIMIT);
+}
+
+function teamKey(team: TeamLike): string {
+  return asString(team.key) ?? asString(team.id) ?? '—';
+}
+
+function privateText(team: TeamLike): string | undefined {
+  if (typeof team.private !== 'boolean') return undefined;
+  return team.private ? 'yes' : 'no';
+}
+
+function stateNodes(team: TeamLike): WorkflowStateLike[] {
+  const nodes = team.states?.nodes;
+  return Array.isArray(nodes) ? nodes : [];
+}
+
+function stateTypeRank(type: string): number {
+  const index = STATE_TYPE_ORDER.indexOf(type.toLowerCase());
+  return index === -1 ? STATE_TYPE_ORDER.length : index;
+}
+
+function statesSummary(team: TeamLike): string | undefined {
+  const states = stateNodes(team);
+  if (states.length === 0) return undefined;
+
+  const counts = new Map<string, number>();
+  for (const state of states) {
+    const type = asString(state.type);
+    if (!type) continue;
+    counts.set(type, (counts.get(type) ?? 0) + 1);
+  }
+
+  if (counts.size === 0) return `${states.length} states`;
+
+  return [...counts.entries()]
+    .sort(
+      ([left], [right]) => stateTypeRank(left) - stateTypeRank(right) || left.localeCompare(right),
+    )
+    .map(([type, count]) => `${type} ${count}`)
+    .join(' · ');
+}
+
+function descriptionSnippet(team: TeamLike): string | undefined {
+  const description = asString(team.description);
+  if (!description) return undefined;
+  return truncate(cleanOneLine(description), DESCRIPTION_LIMIT);
+}
+
+function metadataParts(team: TeamLike): string[] {
+  const privacy = privateText(team);
+  const states = statesSummary(team);
+  const color = asString(team.color);
+  const icon = asString(team.icon);
+  const description = descriptionSnippet(team);
+
+  return [
+    privacy ? `private: ${privacy}` : undefined,
+    states ? `states: ${states}` : undefined,
+    color ? `color: ${color}` : undefined,
+    icon ? `icon: ${icon}` : undefined,
+    description,
+  ].filter((part): part is string => !!part);
+}
+
+function formatTeamListLine(team: TeamLike, theme: Theme, width: number): string {
+  const key = teamKey(team);
+  const keyPrefix = key === '—' ? '' : `${theme.fg('accent', key)} `;
+  const metadata = metadataParts(team);
+  const suffix = metadata.length ? theme.fg('dim', ` · ${metadata.join(' · ')}`) : '';
+
+  return truncateLine(`  ${keyPrefix}${theme.fg('toolOutput', teamName(team))}${suffix}`, width);
+}
+
+function privateStyle(theme: Theme, value: string): (text: string) => string {
+  if (value === 'yes') return (text) => theme.fg('warning', text);
+  if (value === 'no' || value === '—') return (text) => theme.fg('dim', text);
+  return (text) => theme.fg('muted', text);
+}
+
+const TEAM_TABLE_COLUMNS: TableColumn<TeamLike>[] = [
+  {
+    id: 'key',
+    label: 'Key',
+    width: 10,
+    value: teamKey,
+    style: (theme, value) =>
+      value === '—' ? (text) => theme.fg('dim', text) : (text) => theme.fg('accent', text),
+  },
+  {
+    id: 'private',
+    label: 'Private',
+    width: 8,
+    value: (team) => privateText(team) ?? '—',
+    style: privateStyle,
+  },
+  {
+    id: 'states',
+    label: 'States',
+    width: 36,
+    value: (team) => statesSummary(team) ?? '—',
+    style: (theme) => (text) => theme.fg('dim', text),
+  },
+];
+
+function renderTeamTable(teams: TeamLike[], theme: Theme, width: number): string[] {
+  return renderResponsiveTable(teams, theme, width, {
+    columns: TEAM_TABLE_COLUMNS,
+    primary: {
+      label: 'Name',
+      minWidth: TABLE_NAME_MIN_WIDTH,
+      value: teamName,
+      style: (theme) => toolOutputStyle(theme),
+    },
+    dropOrder: ['states', 'private', 'key'],
+    fallback: formatTeamListLine,
+  });
+}
+
+function formatTeamTitle(team: TeamLike, theme: Theme): string {
+  const key = teamKey(team);
+  const prefix = key === '—' ? '' : `${theme.fg('accent', key)} `;
+  return `${prefix}${theme.fg('toolOutput', teamName(team))}`;
+}
+
+function renderTeamCard(
+  actionLabel: string,
+  team: TeamLike | null | undefined,
+  theme: Theme,
+): Text {
+  if (!team) {
+    return new Text(`\n${theme.fg('dim', 'Team not found')}\n\n${jsonHint()}`, 0, 0);
+  }
+
+  const metadata = metadataParts(team);
+
+  let text = `\n${theme.fg('success', `✓ ${actionLabel}`)} ${formatTeamTitle(team, theme)}`;
+  if (metadata.length) text += `\n  ${theme.fg('dim', metadata.join(' · '))}`;
+  text += `\n\n${jsonHint()}`;
+
+  return new Text(text, 0, 0);
+}
+
+export function renderLinearTeamListCall(args: ToolArgs | undefined, theme: Theme): Text {
+  return renderLinearToolCall('linear_list_teams', args, theme, [
+    ['first', 'first'],
+    ['orderBy', 'order'],
+    ['filter', 'filter'],
+    ['includeArchived', 'archived'],
+  ]);
+}
+
+export function renderLinearGetTeamCall(args: ToolArgs | undefined, theme: Theme): Text {
+  return renderLinearToolCall('linear_get_team', args, theme, [['teamId', 'teamId']]);
+}
+
+export function renderLinearTeamListResult(
+  result: AgentToolResult<any>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: LinearToolRenderContext,
+): Text | LinearListResultComponent<TeamLike> {
+  if (options.isPartial) return new Text(theme.fg('warning', 'Loading teams…'), 0, 0);
+  if (shouldShowJson(options, context)) return expandedJson(result, theme);
+
+  const teams = Array.isArray(teamDetails(result).teams)
+    ? (teamDetails(result).teams as TeamLike[])
+    : [];
+
+  return new LinearListResultComponent(teams, theme, {
+    noun: 'team',
+    emptyLabel: 'No teams found',
+    previewLimit: TEAM_LIST_PREVIEW_LIMIT,
+    renderItems: renderTeamTable,
+  });
+}
+
+export function renderLinearTeamResult(actionLabel: string) {
+  return (
+    result: AgentToolResult<any>,
+    options: ToolRenderResultOptions,
+    theme: Theme,
+    context: LinearToolRenderContext,
+  ): Text => {
+    if (options.isPartial) return new Text(theme.fg('warning', `${actionLabel}…`), 0, 0);
+    if (shouldShowJson(options, context)) return expandedJson(result, theme);
+
+    return renderTeamCard(actionLabel, teamDetails(result).team, theme);
+  };
+}

package/extensions/renderers/users.ts

@@ -0,0 +1,242 @@
+import {
+  type AgentToolResult,
+  type Theme,
+  type ToolRenderResultOptions,
+} from '@mariozechner/pi-coding-agent';
+import { Text } from '@mariozechner/pi-tui';
+import {
+  asString,
+  cleanOneLine,
+  dimStyle,
+  expandedJson,
+  shouldShowJson,
+  jsonHint,
+  LinearListResultComponent,
+  mutedStyle,
+  renderLinearToolCall,
+  renderResponsiveTable,
+  toolOutputStyle,
+  truncate,
+  truncateLine,
+  type LinearToolRenderContext,
+  type TableColumn,
+  type ToolArgs,
+} from './common';
+
+type UserLike = {
+  id?: string | null;
+  name?: string | null;
+  displayName?: string | null;
+  email?: string | null;
+  active?: boolean | null;
+  admin?: boolean | null;
+  guest?: boolean | null;
+  isAssignable?: boolean | null;
+  createdAt?: string | null;
+  updatedAt?: string | null;
+  url?: string | null;
+};
+
+type UserResultDetails = {
+  user?: UserLike | null;
+  users?: UserLike[];
+};
+
+const USER_LIST_PREVIEW_LIMIT = 20;
+const NAME_LIMIT = 90;
+const TABLE_NAME_MIN_WIDTH = 24;
+
+function userDetails(result: AgentToolResult<any>): UserResultDetails {
+  return (result.details ?? {}) as UserResultDetails;
+}
+
+function userName(user: UserLike): string {
+  return truncate(
+    cleanOneLine(asString(user.name) ?? asString(user.displayName) ?? '(unnamed user)'),
+    NAME_LIMIT,
+  );
+}
+
+function displayNameText(user: UserLike): string | undefined {
+  const displayName = asString(user.displayName);
+  const name = asString(user.name);
+  if (!displayName || !name || displayName === name) return undefined;
+  return displayName;
+}
+
+function activeText(user: UserLike): string {
+  if (user.active === true) return 'active';
+  if (user.active === false) return 'disabled';
+  return '—';
+}
+
+function roleText(user: UserLike): string {
+  if (user.admin === true) return 'admin';
+  if (user.guest === true) return 'guest';
+  return 'member';
+}
+
+function assignableText(user: UserLike): string {
+  if (user.isAssignable === true) return 'yes';
+  if (user.isAssignable === false) return 'no';
+  return '—';
+}
+
+function metadataParts(user: UserLike): string[] {
+  const displayName = displayNameText(user);
+  const email = asString(user.email);
+
+  return [
+    displayName ? `display: ${displayName}` : undefined,
+    email,
+    activeText(user),
+    roleText(user),
+    `assignable: ${assignableText(user)}`,
+  ].filter((part): part is string => !!part);
+}
+
+function formatUserListLine(user: UserLike, theme: Theme, width: number): string {
+  const metadata = metadataParts(user);
+  const suffix = metadata.length ? theme.fg('dim', ` · ${metadata.join(' · ')}`) : '';
+
+  return truncateLine(`  ${theme.fg('toolOutput', userName(user))}${suffix}`, width);
+}
+
+function activeStyle(theme: Theme, value: string): (text: string) => string {
+  if (value === 'active') return (text) => theme.fg('success', text);
+  if (value === 'disabled') return dimStyle(theme);
+  return mutedStyle(theme);
+}
+
+function roleStyle(theme: Theme, value: string): (text: string) => string {
+  if (value === 'admin') return (text) => theme.fg('warning', text);
+  if (value === 'guest') return mutedStyle(theme);
+  return dimStyle(theme);
+}
+
+function assignableStyle(theme: Theme, value: string): (text: string) => string {
+  if (value === 'yes') return (text) => theme.fg('success', text);
+  if (value === 'no') return dimStyle(theme);
+  return mutedStyle(theme);
+}
+
+const USER_TABLE_COLUMNS: TableColumn<UserLike>[] = [
+  {
+    id: 'email',
+    label: 'Email',
+    width: 30,
+    value: (user) => asString(user.email) ?? '—',
+    style: (theme) => mutedStyle(theme),
+  },
+  {
+    id: 'active',
+    label: 'Active',
+    width: 8,
+    value: activeText,
+    style: activeStyle,
+  },
+  {
+    id: 'role',
+    label: 'Role',
+    width: 7,
+    value: roleText,
+    style: roleStyle,
+  },
+  {
+    id: 'assignable',
+    label: 'Assignable',
+    width: 10,
+    value: assignableText,
+    style: assignableStyle,
+  },
+];
+
+function renderUserTable(users: UserLike[], theme: Theme, width: number): string[] {
+  return renderResponsiveTable(users, theme, width, {
+    columns: USER_TABLE_COLUMNS,
+    primary: {
+      label: 'Name',
+      minWidth: TABLE_NAME_MIN_WIDTH,
+      value: userName,
+      style: (theme) => toolOutputStyle(theme),
+    },
+    dropOrder: ['assignable', 'role', 'active', 'email'],
+    fallback: formatUserListLine,
+  });
+}
+
+function formatUserTitle(user: UserLike, theme: Theme): string {
+  const displayName = displayNameText(user);
+  const name = userName(user);
+  const title = displayName ? `${name} (${truncate(cleanOneLine(displayName), NAME_LIMIT)})` : name;
+  return theme.fg('toolOutput', title);
+}
+
+function renderUserCard(user: UserLike | null | undefined, theme: Theme): Text {
+  if (!user) {
+    return new Text(`\n${theme.fg('dim', 'User not found')}\n\n${jsonHint()}`, 0, 0);
+  }
+
+  const email = asString(user.email);
+  const url = asString(user.url);
+  const metadata = [
+    email,
+    activeText(user),
+    roleText(user),
+    `assignable: ${assignableText(user)}`,
+  ].filter((part): part is string => !!part);
+
+  let text = `\n${theme.fg('success', '✓ User')} ${formatUserTitle(user, theme)}`;
+  if (metadata.length) text += `\n  ${theme.fg('dim', metadata.join(' · '))}`;
+  if (url) text += `\n  ${theme.fg('dim', url)}`;
+  text += `\n\n${jsonHint()}`;
+
+  return new Text(text, 0, 0);
+}
+
+export function renderLinearUserListCall(args: ToolArgs | undefined, theme: Theme): Text {
+  return renderLinearToolCall('linear_list_users', args, theme, [
+    ['first', 'first'],
+    ['orderBy', 'order'],
+    ['filter', 'filter'],
+    ['includeArchived', 'includeArchived'],
+    ['includeDisabled', 'includeDisabled'],
+  ]);
+}
+
+export function renderLinearGetUserCall(args: ToolArgs | undefined, theme: Theme): Text {
+  return renderLinearToolCall('linear_get_user', args, theme, [['userId', 'userId']]);
+}
+
+export function renderLinearUserListResult(
+  result: AgentToolResult<any>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: LinearToolRenderContext,
+): Text | LinearListResultComponent<UserLike> {
+  if (options.isPartial) return new Text(theme.fg('warning', 'Loading users…'), 0, 0);
+  if (shouldShowJson(options, context)) return expandedJson(result, theme);
+
+  const users = Array.isArray(userDetails(result).users)
+    ? (userDetails(result).users as UserLike[])
+    : [];
+
+  return new LinearListResultComponent(users, theme, {
+    noun: 'user',
+    emptyLabel: 'No users found',
+    previewLimit: USER_LIST_PREVIEW_LIMIT,
+    renderItems: renderUserTable,
+  });
+}
+
+export function renderLinearUserResult(
+  result: AgentToolResult<any>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: LinearToolRenderContext,
+): Text {
+  if (options.isPartial) return new Text(theme.fg('warning', 'Loading user…'), 0, 0);
+  if (shouldShowJson(options, context)) return expandedJson(result, theme);
+
+  return renderUserCard(userDetails(result).user, theme);
+}

package/extensions/renderers/workspaces.ts

@@ -0,0 +1,44 @@
+import {
+  type AgentToolResult,
+  type Theme,
+  type ToolRenderResultOptions,
+} from '@mariozechner/pi-coding-agent';
+import { Text } from '@mariozechner/pi-tui';
+import {
+  asString,
+  expandedJson,
+  shouldShowJson,
+  jsonHint,
+  renderLinearToolCall,
+  type LinearToolRenderContext,
+  type ToolArgs,
+} from './common';
+
+type WorkspaceSwitchResultDetails = {
+  active?: string | null;
+};
+
+function workspaceSwitchDetails(result: AgentToolResult<any>): WorkspaceSwitchResultDetails {
+  return (result.details ?? {}) as WorkspaceSwitchResultDetails;
+}
+
+export function renderLinearSwitchWorkspaceCall(args: ToolArgs | undefined, theme: Theme): Text {
+  return renderLinearToolCall('linear_switch_workspace', args, theme, [['name', 'name']]);
+}
+
+export function renderLinearSwitchWorkspaceResult(
+  result: AgentToolResult<any>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: LinearToolRenderContext,
+): Text {
+  if (options.isPartial) return new Text(theme.fg('warning', 'Switching workspace…'), 0, 0);
+  if (shouldShowJson(options, context)) return expandedJson(result, theme);
+
+  const active = asString(workspaceSwitchDetails(result).active) ?? 'unknown';
+  return new Text(
+    `\n${theme.fg('success', `✓ Active Linear workspace: ${active}`)}\n\n${jsonHint()}`,
+    0,
+    0,
+  );
+}

package/extensions/selections.ts

@@ -94,7 +94,7 @@ export const ISSUE_LABEL_SELECTION = `
     }
   `;
 
-export const PROJECT_SELECTION = `
+const PROJECT_BASE_SELECTION = `
     id
     name
     description
@@ -116,7 +116,7 @@ export const PROJECT_SELECTION = `
     createdAt
     updatedAt
     url
-    teams {
+    teams(first: 10) {
       nodes {
         id
         key
@@ -128,7 +128,7 @@ export const PROJECT_SELECTION = `
       name
       email
     }
-    members {
+    members(first: 10) {
       nodes {
         id
         name
@@ -141,6 +141,13 @@ export const PROJECT_SELECTION = `
     }
   `;
 
+export const PROJECT_LIST_SELECTION = PROJECT_BASE_SELECTION;
+
+export const PROJECT_DETAIL_SELECTION = `
+    ${PROJECT_BASE_SELECTION}
+    content
+  `;
+
 export const PROJECT_LABEL_SELECTION = `
     id
     name

package/extensions/settings.ts

@@ -3,6 +3,7 @@ import { dirname, join } from 'node:path';
 import type { ExtensionAPI, ExtensionContext } from '@mariozechner/pi-coding-agent';
 import { getAgentDir, getSettingsListTheme } from '@mariozechner/pi-coding-agent';
 import { type SettingItem, SettingsList } from '@mariozechner/pi-tui';
+import { invalidateLinearResultRenderers, setDefaultJsonView } from './renderers/state';
 
 const SETTINGS_PATH = join(getAgentDir(), 'state', 'extensions', 'linear', 'tool-settings.json');
 const OVERLAY_MAX_INNER = 60;
@@ -166,28 +167,37 @@ const ALL_LINEAR_TOOLS = TOOL_CATEGORIES.flatMap((c) => c.tools);
 
 type ToolSettings = {
   disabledTools: string[];
+  defaultJsonView: boolean;
 };
 
 function createDefaultSettings(): ToolSettings {
-  return { disabledTools: [] };
+  return { disabledTools: [], defaultJsonView: false };
 }
 
 async function loadSettings(): Promise<ToolSettings> {
   try {
     const raw = JSON.parse(await fs.readFile(SETTINGS_PATH, 'utf8'));
     if (!raw || typeof raw !== 'object' || !Array.isArray(raw.disabledTools)) {
-      return createDefaultSettings();
+      const settings = createDefaultSettings();
+      setDefaultJsonView(settings.defaultJsonView);
+      return settings;
     }
-    return {
+    const settings = {
       disabledTools: raw.disabledTools.filter((t: unknown) => typeof t === 'string'),
+      defaultJsonView: typeof raw.defaultJsonView === 'boolean' ? raw.defaultJsonView : false,
     };
+    setDefaultJsonView(settings.defaultJsonView);
+    return settings;
   } catch {
-    return createDefaultSettings();
+    const settings = createDefaultSettings();
+    setDefaultJsonView(settings.defaultJsonView);
+    return settings;
   }
 }
 
 async function saveSettings(settings: ToolSettings): Promise<boolean> {
   try {
+    setDefaultJsonView(settings.defaultJsonView);
     await fs.mkdir(dirname(SETTINGS_PATH), { recursive: true });
     await fs.writeFile(SETTINGS_PATH, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
     return true;
@@ -256,8 +266,21 @@ function frameBody(title: string, bodyLines: string[], inner: number): string[]
   return [top, ...framedBody, bottom];
 }
 
+function defaultOutputViewValue(settings: ToolSettings): string {
+  return settings.defaultJsonView ? 'Full JSON' : 'Human readable';
+}
+
 function buildItems(settings: ToolSettings): SettingItem[] {
-  const items: SettingItem[] = [];
+  const items: SettingItem[] = [
+    {
+      id: 'defaultJsonView',
+      label: 'Default output view',
+      description:
+        'Controls Linear tool result display. Ctrl+O toggles the other view per tool call.',
+      currentValue: defaultOutputViewValue(settings),
+      values: ['Human readable', 'Full JSON'],
+    },
+  ];
   for (const category of TOOL_CATEGORIES) {
     items.push({
       id: `category:${category.id}`,
@@ -308,7 +331,7 @@ async function showToolSettingsOverlay(
     () => {},
   );
   const probeLines = probeList.render(Math.max(8, OVERLAY_MAX_INNER - 2));
-  const overlayBodyLines = ['Toggle Linear tools by category or individually', '', ...probeLines];
+  const overlayBodyLines = ['Configure Linear output and enabled tools', '', ...probeLines];
   const overlayWidth = computeOverlayInner(overlayBodyLines, OVERLAY_MAX_INNER + 2) + 2;
 
   await ctx.ui.custom(
@@ -318,6 +341,16 @@ async function showToolSettingsOverlay(
         maxVisibleItems,
         settingsTheme,
         async (id, newValue) => {
+          if (id === 'defaultJsonView') {
+            const previousDefaultJsonView = settings.defaultJsonView;
+            settings.defaultJsonView = newValue === 'Full JSON';
+            await saveSettings(settings);
+            if (settings.defaultJsonView !== previousDefaultJsonView) {
+              invalidateLinearResultRenderers();
+            }
+            return;
+          }
+
           const nextEnabled = newValue === '[x]';
 
           if (id.startsWith('category:')) {
@@ -364,7 +397,7 @@ async function showToolSettingsOverlay(
           const provisionalInner = Math.max(24, Math.min(safeWidth - 2, OVERLAY_MAX_INNER));
           const listLines = settingsList.render(Math.max(8, provisionalInner - 2));
           const bodyLines = [
-            theme.fg('muted', 'Toggle Linear tools by category or individually'),
+            theme.fg('muted', 'Configure Linear output and enabled tools'),
             '',
             ...listLines,
           ];