@colmbus72/yeehaw 0.5.0 → 0.6.0

package/dist/lib/issues/linear.js

@@ -0,0 +1,345 @@
+import { isLinearAuthenticated, linearGraphQL } from '../auth/index.js';
+// GraphQL queries
+const TEAMS_QUERY = `
+  query {
+    teams {
+      nodes {
+        id
+        name
+        key
+      }
+    }
+  }
+`;
+const VIEWER_QUERY = `
+  query {
+    viewer {
+      id
+      name
+      displayName
+    }
+  }
+`;
+const CYCLES_QUERY = `
+  query($teamId: String!) {
+    team(id: $teamId) {
+      cycles(orderBy: startsAt, first: 20) {
+        nodes {
+          id
+          name
+          number
+          startsAt
+          endsAt
+        }
+      }
+      activeCycle {
+        id
+        name
+        number
+      }
+    }
+  }
+`;
+const ASSIGNEES_QUERY = `
+  query($teamId: String!) {
+    team(id: $teamId) {
+      members {
+        nodes {
+          id
+          name
+          displayName
+        }
+      }
+    }
+  }
+`;
+const ISSUES_QUERY = `
+  query($teamId: String!, $first: Int, $filter: IssueFilter) {
+    team(id: $teamId) {
+      issues(first: $first, filter: $filter, orderBy: updatedAt) {
+        nodes {
+          id
+          identifier
+          title
+          description
+          url
+          createdAt
+          updatedAt
+          priority
+          estimate
+          state {
+            name
+            type
+          }
+          creator {
+            name
+          }
+          assignee {
+            id
+            name
+            displayName
+          }
+          cycle {
+            id
+            name
+            number
+          }
+          labels {
+            nodes {
+              name
+            }
+          }
+          comments {
+            nodes {
+              id
+              body
+              createdAt
+              user {
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+const ISSUE_QUERY = `
+  query($id: String!) {
+    issue(id: $id) {
+      id
+      identifier
+      title
+      description
+      url
+      createdAt
+      updatedAt
+      priority
+      estimate
+      state {
+        name
+        type
+      }
+      creator {
+        name
+      }
+      assignee {
+        id
+        name
+        displayName
+      }
+      cycle {
+        id
+        name
+        number
+      }
+      labels {
+        nodes {
+          name
+        }
+      }
+      comments {
+        nodes {
+          id
+          body
+          createdAt
+          user {
+            name
+          }
+        }
+      }
+      team {
+        name
+      }
+    }
+  }
+`;
+export class LinearProvider {
+    type = 'linear';
+    teamId;
+    teamName;
+    cachedUserId;
+    cachedActiveCycleId;
+    constructor(teamId, teamName) {
+        this.teamId = teamId;
+        this.teamName = teamName;
+    }
+    async isAuthenticated() {
+        return isLinearAuthenticated();
+    }
+    async authenticate() {
+        throw new Error('Use saveLinearApiKey() to authenticate with a Personal API Key');
+    }
+    needsTeamSelection() {
+        return !this.teamId;
+    }
+    async fetchTeams() {
+        const data = await linearGraphQL(TEAMS_QUERY);
+        return data.teams.nodes;
+    }
+    setTeamId(teamId) {
+        this.teamId = teamId;
+    }
+    setTeamName(teamName) {
+        this.teamName = teamName;
+    }
+    getTeamName() {
+        return this.teamName;
+    }
+    async fetchTeamName() {
+        if (this.teamName)
+            return this.teamName;
+        if (!this.teamId)
+            return undefined;
+        try {
+            const data = await linearGraphQL(`query($teamId: String!) { team(id: $teamId) { name } }`, { teamId: this.teamId });
+            this.teamName = data.team.name;
+            return this.teamName;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getCurrentUserId() {
+        if (this.cachedUserId !== undefined) {
+            return this.cachedUserId;
+        }
+        try {
+            const data = await linearGraphQL(VIEWER_QUERY);
+            this.cachedUserId = data.viewer.id;
+            return this.cachedUserId;
+        }
+        catch {
+            this.cachedUserId = null;
+            return null;
+        }
+    }
+    async fetchCycles() {
+        if (!this.teamId) {
+            throw new Error('Team not selected');
+        }
+        const data = await linearGraphQL(CYCLES_QUERY, { teamId: this.teamId });
+        // Cache the active cycle ID
+        if (data.team.activeCycle) {
+            this.cachedActiveCycleId = data.team.activeCycle.id;
+        }
+        return data.team.cycles.nodes.map((c) => ({
+            id: c.id,
+            name: c.name || `Cycle ${c.number}`,
+            number: c.number,
+        }));
+    }
+    getActiveCycleId() {
+        return this.cachedActiveCycleId;
+    }
+    async fetchAssignees() {
+        if (!this.teamId) {
+            throw new Error('Team not selected');
+        }
+        const data = await linearGraphQL(ASSIGNEES_QUERY, { teamId: this.teamId });
+        return data.team.members.nodes;
+    }
+    async fetchIssues(options = {}) {
+        if (!this.teamId) {
+            throw new Error('Team not selected');
+        }
+        const { state = 'open', limit = 50, linearFilter } = options;
+        // Build filter object
+        const filter = {};
+        // State filter
+        if (state === 'open') {
+            filter.state = { type: { in: ['backlog', 'unstarted', 'started'] } };
+        }
+        else if (state === 'closed') {
+            filter.state = { type: { in: ['completed', 'canceled'] } };
+        }
+        // Linear-specific filters
+        if (linearFilter) {
+            // Assignee filter
+            if (linearFilter.assigneeId !== undefined) {
+                if (linearFilter.assigneeId === null) {
+                    filter.assignee = { null: true };
+                }
+                else {
+                    filter.assignee = { id: { eq: linearFilter.assigneeId } };
+                }
+            }
+            // Cycle filter
+            if (linearFilter.cycleId) {
+                filter.cycle = { id: { eq: linearFilter.cycleId } };
+            }
+            // State type filter (overrides basic state filter)
+            if (linearFilter.stateType) {
+                const types = Array.isArray(linearFilter.stateType)
+                    ? linearFilter.stateType
+                    : [linearFilter.stateType];
+                filter.state = { type: { in: types } };
+            }
+        }
+        const data = await linearGraphQL(ISSUES_QUERY, { teamId: this.teamId, first: limit, filter: Object.keys(filter).length > 0 ? filter : undefined });
+        let issues = data.team.issues.nodes.map((issue) => this.normalizeIssue(issue));
+        // Client-side sorting
+        if (linearFilter?.sortBy === 'priority') {
+            // Priority: 1 = urgent (highest), 4 = low, 0 = no priority (lowest)
+            issues = issues.sort((a, b) => {
+                const aPri = a.priority === 0 ? 5 : (a.priority ?? 5);
+                const bPri = b.priority === 0 ? 5 : (b.priority ?? 5);
+                return linearFilter.sortDirection === 'desc' ? aPri - bPri : bPri - aPri;
+            });
+        }
+        else if (linearFilter?.sortBy === 'createdAt') {
+            issues = issues.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        }
+        // Default: already sorted by updatedAt from API
+        return issues;
+    }
+    async getIssue(id) {
+        const data = await linearGraphQL(ISSUE_QUERY, { id });
+        return this.normalizeIssue(data.issue);
+    }
+    normalizeIssue(issue) {
+        const openStateTypes = ['backlog', 'unstarted', 'started'];
+        const isOpen = openStateTypes.includes(issue.state.type);
+        const comments = issue.comments.nodes.map((c) => ({
+            id: c.id,
+            author: c.user?.name || 'Unknown',
+            body: c.body,
+            createdAt: c.createdAt,
+        }));
+        return {
+            id: issue.id,
+            identifier: issue.identifier,
+            title: issue.title,
+            state: issue.state.name,
+            stateType: issue.state.type,
+            isOpen,
+            author: issue.creator?.name || 'Unknown',
+            body: issue.description || '',
+            labels: issue.labels.nodes.map((l) => l.name),
+            url: issue.url,
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt,
+            comments,
+            source: {
+                type: 'linear',
+                team: issue.team?.name || this.teamName || 'Unknown',
+            },
+            priority: issue.priority,
+            estimate: issue.estimate ?? undefined,
+            assignee: issue.assignee
+                ? {
+                    id: issue.assignee.id,
+                    name: issue.assignee.name,
+                    displayName: issue.assignee.displayName,
+                }
+                : undefined,
+            cycle: issue.cycle
+                ? {
+                    id: issue.cycle.id,
+                    name: issue.cycle.name || `Cycle ${issue.cycle.number}`,
+                    number: issue.cycle.number,
+                }
+                : undefined,
+        };
+    }
+}

package/dist/lib/issues/types.d.ts

@@ -0,0 +1,82 @@
+export interface IssueComment {
+    id: string;
+    author: string;
+    body: string;
+    createdAt: string;
+}
+export type LinearPriority = 0 | 1 | 2 | 3 | 4;
+export type LinearStateType = 'backlog' | 'unstarted' | 'started' | 'completed' | 'canceled' | 'triage';
+export interface LinearAssignee {
+    id: string;
+    name: string;
+    displayName: string;
+}
+export interface LinearCycle {
+    id: string;
+    name: string;
+    number: number;
+}
+export interface Issue {
+    id: string;
+    identifier: string;
+    title: string;
+    state: string;
+    stateType?: LinearStateType;
+    isOpen: boolean;
+    author: string;
+    body: string;
+    labels: string[];
+    url: string;
+    createdAt: string;
+    updatedAt: string;
+    comments: IssueComment[];
+    source: IssueSource;
+    priority?: LinearPriority;
+    estimate?: number;
+    assignee?: LinearAssignee;
+    cycle?: LinearCycle;
+}
+export type IssueSource = {
+    type: 'github';
+    repo: string;
+    livestockName: string;
+    livestockPath: string;
+} | {
+    type: 'linear';
+    team: string;
+};
+export interface LinearIssueFilter {
+    assigneeId?: string | null;
+    cycleId?: string;
+    stateType?: LinearStateType | LinearStateType[];
+    sortBy?: 'priority' | 'updatedAt' | 'createdAt';
+    sortDirection?: 'asc' | 'desc';
+}
+export interface FetchIssuesOptions {
+    state?: 'open' | 'closed' | 'all';
+    limit?: number;
+    linearFilter?: LinearIssueFilter;
+}
+export interface IssueProvider {
+    readonly type: 'github' | 'linear';
+    isAuthenticated(): Promise<boolean>;
+    authenticate(): Promise<void>;
+    fetchIssues(options?: FetchIssuesOptions): Promise<Issue[]>;
+    getIssue(id: string): Promise<Issue>;
+}
+export interface LinearProviderInterface extends IssueProvider {
+    readonly type: 'linear';
+    needsTeamSelection(): boolean;
+    fetchTeams(): Promise<LinearTeam[]>;
+    setTeamId(teamId: string): void;
+    setTeamName(teamName: string): void;
+    getTeamName(): string | undefined;
+    fetchCycles(): Promise<LinearCycle[]>;
+    fetchAssignees(): Promise<LinearAssignee[]>;
+    getCurrentUserId(): Promise<string | null>;
+}
+export interface LinearTeam {
+    id: string;
+    name: string;
+    key: string;
+}

package/dist/lib/issues/types.js

@@ -0,0 +1,2 @@
+// src/lib/issues/types.ts
+export {};

package/dist/lib/paths.d.ts

@@ -1,5 +1,6 @@
 export declare const YEEHAW_DIR: string;
 export declare const CONFIG_FILE: string;
+export declare const AUTH_FILE: string;
 export declare const PROJECTS_DIR: string;
 export declare const BARNS_DIR: string;
 export declare const SESSIONS_DIR: string;

package/dist/lib/paths.js

@@ -2,6 +2,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 export const YEEHAW_DIR = join(homedir(), '.yeehaw');
 export const CONFIG_FILE = join(YEEHAW_DIR, 'config.yaml');
+export const AUTH_FILE = join(YEEHAW_DIR, 'auth.yaml');
 export const PROJECTS_DIR = join(YEEHAW_DIR, 'projects');
 export const BARNS_DIR = join(YEEHAW_DIR, 'barns');
 export const SESSIONS_DIR = join(YEEHAW_DIR, 'sessions');

package/dist/lib/tmux.d.ts

@@ -24,6 +24,7 @@ export declare function setupStatusBarHooks(): void;
 export declare function ensureCorrectStatusBar(): void;
 export declare function attachToYeehaw(): void;
 export declare function createClaudeWindow(workingDir: string, windowName: string): number;
+export declare function createClaudeWindowWithPrompt(workingDir: string, windowName: string, systemPrompt: string): number;
 export declare function createShellWindow(workingDir: string, windowName: string, shell?: string): number;
 export declare function createSshWindow(windowName: string, host: string, user: string, port: number, identityFile: string, remotePath: string): number;
 export declare function detachFromSession(): void;

package/dist/lib/tmux.js

@@ -131,19 +131,31 @@ export function attachToYeehaw() {
 }
 // All yeehaw MCP tools that should be auto-approved
 const YEEHAW_MCP_TOOLS = [
+    // Project management
     'mcp__yeehaw__list_projects',
     'mcp__yeehaw__get_project',
     'mcp__yeehaw__create_project',
     'mcp__yeehaw__update_project',
     'mcp__yeehaw__delete_project',
+    // Livestock management
     'mcp__yeehaw__add_livestock',
     'mcp__yeehaw__remove_livestock',
+    'mcp__yeehaw__read_livestock_logs',
+    'mcp__yeehaw__read_livestock_env',
+    // Barn management
     'mcp__yeehaw__list_barns',
     'mcp__yeehaw__get_barn',
     'mcp__yeehaw__create_barn',
     'mcp__yeehaw__update_barn',
     'mcp__yeehaw__delete_barn',
+    // Critter management
+    'mcp__yeehaw__add_critter',
+    'mcp__yeehaw__remove_critter',
+    'mcp__yeehaw__read_critter_logs',
+    'mcp__yeehaw__discover_critters',
+    // Wiki management
     'mcp__yeehaw__get_wiki',
+    'mcp__yeehaw__get_wiki_section',
     'mcp__yeehaw__add_wiki_section',
     'mcp__yeehaw__update_wiki_section',
     'mcp__yeehaw__delete_wiki_section',
@@ -190,6 +202,39 @@ export function createClaudeWindow(workingDir, windowName) {
     setWindowType(windowIndex, 'claude');
     return windowIndex;
 }
+export function createClaudeWindowWithPrompt(workingDir, windowName, systemPrompt) {
+    // Build MCP config for yeehaw server
+    const mcpConfig = JSON.stringify({
+        mcpServers: {
+            yeehaw: {
+                command: 'node',
+                args: [MCP_SERVER_PATH],
+            },
+        },
+    });
+    // Build allowed tools list for auto-approval
+    const allowedTools = YEEHAW_MCP_TOOLS.join(',');
+    // Escape the system prompt for shell - use single quotes and escape any single quotes in content
+    const escapedPrompt = systemPrompt.replace(/'/g, "'\\''");
+    // Create new window running claude with yeehaw MCP server and system prompt
+    const claudeCmd = `claude --mcp-config ${shellEscape(mcpConfig)} --allowedTools ${shellEscape(allowedTools)} --plugin-dir ${shellEscape(CLAUDE_PLUGIN_PATH)} --system-prompt '${escapedPrompt}'`;
+    execaSync('tmux', [
+        'new-window',
+        '-a',
+        '-t', YEEHAW_SESSION,
+        '-n', windowName,
+        '-c', workingDir,
+        claudeCmd,
+    ]);
+    // Get the window index we just created
+    const result = execaSync('tmux', [
+        'display-message', '-p', '#{window_index}'
+    ]);
+    const windowIndex = parseInt(result.stdout.trim(), 10);
+    // Mark this window as a Claude session
+    setWindowType(windowIndex, 'claude');
+    return windowIndex;
+}
 export function createShellWindow(workingDir, windowName, shell) {
     // Use the user's configured shell from $SHELL, fallback to /bin/bash
     const userShell = shell || process.env.SHELL || '/bin/bash';

package/dist/types.d.ts

@@ -24,11 +24,21 @@ export interface Project {
     gradientInverted?: boolean;
     livestock?: Livestock[];
     wiki?: WikiSection[];
+    issueProvider?: IssueProviderConfig;
 }
 export interface WikiSection {
     title: string;
     content: string;
 }
+export type IssueProviderConfig = {
+    type: 'github';
+} | {
+    type: 'linear';
+    teamId?: string;
+    teamName?: string;
+} | {
+    type: 'none';
+};
 export interface Livestock {
     name: string;
     path: string;
@@ -41,6 +51,7 @@ export interface Livestock {
 export interface Critter {
     name: string;
     service: string;
+    service_path?: string;
     config_path?: string;
     log_path?: string;
     use_journald?: boolean;
@@ -92,6 +103,14 @@ export type AppView = {
     livestock: Livestock;
     source: 'project' | 'barn';
     sourceBarn?: Barn;
+} | {
+    type: 'critter';
+    barn: Barn;
+    critter: Critter;
+} | {
+    type: 'critter-logs';
+    barn: Barn;
+    critter: Critter;
 } | {
     type: 'night-sky';
 };

package/dist/views/BarnContext.d.ts

@@ -19,6 +19,7 @@ interface BarnContextProps {
     onRemoveLivestock: (project: Project, livestockName: string) => void;
     onAddCritter: (critter: Critter) => void;
     onRemoveCritter: (critterName: string) => void;
+    onSelectCritter: (critter: Critter) => void;
 }
-export declare function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, onAddCritter, onRemoveCritter, }: BarnContextProps): import("react/jsx-runtime").JSX.Element;
+export declare function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, onAddCritter, onRemoveCritter, onSelectCritter, }: BarnContextProps): import("react/jsx-runtime").JSX.Element;
 export {};