@alasano/pi-linear 0.1.0 → 0.2.0

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/settings.ts

@@ -1,8 +1,9 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { promises as fs } from 'node:fs';
 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,33 +167,39 @@ 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 };
 }
 
-function loadSettings(): ToolSettings {
-  if (!existsSync(SETTINGS_PATH)) {
-    return createDefaultSettings();
-  }
+async function loadSettings(): Promise<ToolSettings> {
   try {
-    const raw = JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'));
+    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;
   }
 }
 
-function saveSettings(settings: ToolSettings): boolean {
+async function saveSettings(settings: ToolSettings): Promise<boolean> {
   try {
-    mkdirSync(dirname(SETTINGS_PATH), { recursive: true });
-    writeFileSync(SETTINGS_PATH, `${JSON.stringify(settings, null, 2)}\n`, 'utf8');
+    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;
   } catch {
     return false;
@@ -259,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}`,
@@ -311,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(
@@ -320,7 +340,17 @@ async function showToolSettingsOverlay(
         items,
         maxVisibleItems,
         settingsTheme,
-        (id, newValue) => {
+        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:')) {
@@ -354,7 +384,7 @@ async function showToolSettingsOverlay(
             }
           }
 
-          saveSettings(settings);
+          await saveSettings(settings);
           applySettings(pi, settings);
         },
         () => done(undefined),
@@ -367,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,
           ];
@@ -392,24 +422,24 @@ async function showToolSettingsOverlay(
   );
 }
 
-export function registerLinearSettings(pi: ExtensionAPI): void {
-  let settings = loadSettings();
+export async function registerLinearSettings(pi: ExtensionAPI): Promise<void> {
+  let settings = await loadSettings();
 
   pi.registerCommand('linear-settings', {
     description: 'Open Linear tool settings',
     handler: async (_args, ctx) => {
-      settings = loadSettings();
+      settings = await loadSettings();
       await showToolSettingsOverlay(pi, ctx, settings);
     },
   });
 
   pi.on('session_start', async (_event, _ctx) => {
-    settings = loadSettings();
+    settings = await loadSettings();
     applySettings(pi, settings);
   });
 
   pi.on('session_before_switch', async (_event, _ctx) => {
-    settings = loadSettings();
+    settings = await loadSettings();
     applySettings(pi, settings);
   });
 }

package/extensions/tools/comments.ts

@@ -5,6 +5,15 @@ import { PaginationParams, FilterParam, RawInputParam } from '../params';
 import { COMMENT_SELECTION } from '../selections';
 import type { JsonObject } from '../types';
 import { compactObject, asObject, asString, GenericObjectSchema } from '../util';
+import {
+  renderLinearCommentListCall,
+  renderLinearCommentListResult,
+  renderLinearCommentResult,
+  renderLinearCreateCommentCall,
+  renderLinearDeleteCommentCall,
+  renderLinearDeleteCommentResult,
+  renderLinearUpdateCommentCall,
+} from '../renderers/comments';
 
 export function commentTools() {
   return [
@@ -16,6 +25,7 @@ export function commentTools() {
         ...PaginationParams,
         ...FilterParam,
       }),
+      renderCall: renderLinearCommentListCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const variables = compactObject({
@@ -66,6 +76,7 @@ export function commentTools() {
           };
         });
       },
+      renderResult: renderLinearCommentListResult,
     }),
     defineTool({
       name: 'linear_create_comment',
@@ -90,6 +101,7 @@ export function commentTools() {
         subscriberIds: Type.Optional(Type.Array(Type.String())),
         ...RawInputParam,
       }),
+      renderCall: renderLinearCreateCommentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const rawInput = asObject(params.input) || {};
@@ -146,6 +158,7 @@ export function commentTools() {
           };
         });
       },
+      renderResult: renderLinearCommentResult('Created comment'),
     }),
     defineTool({
       name: 'linear_update_comment',
@@ -157,6 +170,7 @@ export function commentTools() {
         quotedText: Type.Optional(Type.String()),
         ...RawInputParam,
       }),
+      renderCall: renderLinearUpdateCommentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const rawInput = asObject(params.input) || {};
@@ -199,6 +213,7 @@ export function commentTools() {
           };
         });
       },
+      renderResult: renderLinearCommentResult('Updated comment'),
     }),
     defineTool({
       name: 'linear_delete_comment',
@@ -207,6 +222,7 @@ export function commentTools() {
       parameters: Type.Object({
         id: Type.String(),
       }),
+      renderCall: renderLinearDeleteCommentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const data = await linearGraphQL<{
@@ -232,6 +248,7 @@ export function commentTools() {
           };
         });
       },
+      renderResult: renderLinearDeleteCommentResult,
     }),
   ];
 }

package/extensions/tools/documents.ts

@@ -5,6 +5,17 @@ import { PaginationParams, FilterParam, RawInputParam, TeamConvenienceParams } f
 import { DOCUMENT_SELECTION } from '../selections';
 import type { JsonObject } from '../types';
 import { compactObject, asObject, asString } from '../util';
+import {
+  renderLinearCreateDocumentCall,
+  renderLinearDeleteDocumentCall,
+  renderLinearDocumentListCall,
+  renderLinearDocumentListResult,
+  renderLinearDocumentResult,
+  renderLinearDocumentSuccessResult,
+  renderLinearGetDocumentCall,
+  renderLinearUnarchiveDocumentCall,
+  renderLinearUpdateDocumentCall,
+} from '../renderers/documents';
 
 export function documentTools() {
   return [
@@ -16,6 +27,7 @@ export function documentTools() {
         ...PaginationParams,
         ...FilterParam,
       }),
+      renderCall: renderLinearDocumentListCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const variables = compactObject({
@@ -66,6 +78,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentListResult,
     }),
     defineTool({
       name: 'linear_get_document',
@@ -74,6 +87,7 @@ export function documentTools() {
       parameters: Type.Object({
         documentId: Type.String(),
       }),
+      renderCall: renderLinearGetDocumentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const data = await linearGraphQL<{ document: JsonObject | null }>(
@@ -96,6 +110,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentResult('Document'),
     }),
     defineTool({
       name: 'linear_create_document',
@@ -120,6 +135,7 @@ export function documentTools() {
         title: Type.Optional(Type.String()),
         ...RawInputParam,
       }),
+      renderCall: renderLinearCreateDocumentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const rawInput = asObject(params.input) || {};
@@ -188,6 +204,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentResult('Created document'),
     }),
     defineTool({
       name: 'linear_update_document',
@@ -214,6 +231,7 @@ export function documentTools() {
         trashed: Type.Optional(Type.Boolean()),
         ...RawInputParam,
       }),
+      renderCall: renderLinearUpdateDocumentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const rawInput = asObject(params.input) || {};
@@ -286,6 +304,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentResult('Updated document'),
     }),
     defineTool({
       name: 'linear_delete_document',
@@ -294,6 +313,7 @@ export function documentTools() {
       parameters: Type.Object({
         documentId: Type.String(),
       }),
+      renderCall: renderLinearDeleteDocumentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const data = await linearGraphQL<{
@@ -319,6 +339,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentSuccessResult('Deleted'),
     }),
     defineTool({
       name: 'linear_unarchive_document',
@@ -327,6 +348,7 @@ export function documentTools() {
       parameters: Type.Object({
         documentId: Type.String(),
       }),
+      renderCall: renderLinearUnarchiveDocumentCall,
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {
         return withLinearAuth(ctx, signal, async (apiKey) => {
           const data = await linearGraphQL<{
@@ -352,6 +374,7 @@ export function documentTools() {
           };
         });
       },
+      renderResult: renderLinearDocumentSuccessResult('Unarchived'),
     }),
   ];
 }