@colmbus72/yeehaw 0.4.2 → 0.6.0

package/dist/lib/issues/github.js

@@ -0,0 +1,154 @@
+// src/lib/issues/github.ts
+import { execaSync } from 'execa';
+/**
+ * Parse a GitHub URL to extract owner and repo.
+ */
+function parseGitHubUrl(url) {
+    // HTTPS format
+    const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.\s]+)/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2].replace(/\.git$/, '') };
+    }
+    // SSH format
+    const sshMatch = url.match(/github\.com:([^/]+)\/([^/.\s]+)/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2].replace(/\.git$/, '') };
+    }
+    return null;
+}
+export class GitHubProvider {
+    type = 'github';
+    repos = [];
+    constructor(livestock) {
+        // Extract GitHub repos from local livestock only
+        const localLivestock = livestock.filter((l) => !l.barn && l.repo);
+        const seen = new Set();
+        for (const l of localLivestock) {
+            if (!l.repo)
+                continue;
+            const parsed = parseGitHubUrl(l.repo);
+            if (parsed) {
+                const key = `${parsed.owner}/${parsed.repo}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    this.repos.push({
+                        ...parsed,
+                        livestockName: l.name,
+                        livestockPath: l.path,
+                    });
+                }
+            }
+        }
+    }
+    async isAuthenticated() {
+        try {
+            execaSync('gh', ['auth', 'status']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async authenticate() {
+        // GitHub auth is handled externally via `gh auth login`
+        // This is a no-op - the view should display instructions
+        throw new Error('Run `gh auth login` in your terminal to authenticate with GitHub');
+    }
+    async fetchIssues(options = {}) {
+        const { state = 'open', limit = 50 } = options;
+        if (this.repos.length === 0) {
+            return [];
+        }
+        const allIssues = [];
+        for (const repo of this.repos) {
+            try {
+                const result = execaSync('gh', [
+                    'issue', 'list',
+                    '--repo', `${repo.owner}/${repo.repo}`,
+                    '--state', state,
+                    '--limit', String(limit),
+                    '--json', 'number,title,state,author,labels,createdAt,updatedAt,body,url,comments',
+                ]);
+                const issues = JSON.parse(result.stdout);
+                for (const issue of issues) {
+                    allIssues.push({
+                        id: `${repo.owner}/${repo.repo}#${issue.number}`,
+                        identifier: `#${issue.number}`,
+                        title: issue.title,
+                        state: issue.state.toLowerCase(),
+                        isOpen: issue.state.toLowerCase() === 'open',
+                        author: issue.author.login,
+                        body: issue.body || '',
+                        labels: issue.labels.map((l) => l.name),
+                        url: issue.url,
+                        createdAt: issue.createdAt,
+                        updatedAt: issue.updatedAt,
+                        comments: issue.comments.map((c) => ({
+                            id: `${issue.number}-${c.createdAt}`,
+                            author: c.author.login,
+                            body: c.body,
+                            createdAt: c.createdAt,
+                        })),
+                        source: {
+                            type: 'github',
+                            repo: `${repo.owner}/${repo.repo}`,
+                            livestockName: repo.livestockName,
+                            livestockPath: repo.livestockPath,
+                        },
+                    });
+                }
+            }
+            catch (err) {
+                console.error(`[github] Failed to fetch issues for ${repo.owner}/${repo.repo}:`, err);
+            }
+        }
+        // Sort by updated date (most recent first)
+        allIssues.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return allIssues;
+    }
+    async getIssue(id) {
+        // Parse id format: "owner/repo#number"
+        const match = id.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+        if (!match) {
+            throw new Error(`Invalid issue ID format: ${id}`);
+        }
+        const [, owner, repo, numberStr] = match;
+        const issueNumber = parseInt(numberStr, 10);
+        // Find the livestock for this repo
+        const repoInfo = this.repos.find((r) => r.owner === owner && r.repo === repo);
+        if (!repoInfo) {
+            throw new Error(`Repo not found in livestock: ${owner}/${repo}`);
+        }
+        const result = execaSync('gh', [
+            'issue', 'view', String(issueNumber),
+            '--repo', `${owner}/${repo}`,
+            '--json', 'number,title,state,author,labels,createdAt,updatedAt,body,url,comments',
+        ]);
+        const issue = JSON.parse(result.stdout);
+        return {
+            id,
+            identifier: `#${issue.number}`,
+            title: issue.title,
+            state: issue.state.toLowerCase(),
+            isOpen: issue.state.toLowerCase() === 'open',
+            author: issue.author.login,
+            body: issue.body || '',
+            labels: issue.labels.map((l) => l.name),
+            url: issue.url,
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt,
+            comments: issue.comments.map((c) => ({
+                id: `${issue.number}-${c.createdAt}`,
+                author: c.author.login,
+                body: c.body,
+                createdAt: c.createdAt,
+            })),
+            source: {
+                type: 'github',
+                repo: `${owner}/${repo}`,
+                livestockName: repoInfo.livestockName,
+                livestockPath: repoInfo.livestockPath,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { Project } from '../../types.js';
+import type { IssueProvider } from './types.js';
+export * from './types.js';
+export { GitHubProvider } from './github.js';
+export { LinearProvider } from './linear.js';
+/**
+ * Get the appropriate issue provider for a project.
+ * Returns null if issue tracking is disabled.
+ */
+export declare function getProvider(project: Project): IssueProvider | null;
+/**
+ * Check if a project has issue tracking enabled.
+ */
+export declare function hasIssueTracking(project: Project): boolean;

package/dist/lib/issues/index.js

@@ -0,0 +1,27 @@
+import { GitHubProvider } from './github.js';
+import { LinearProvider } from './linear.js';
+export * from './types.js';
+export { GitHubProvider } from './github.js';
+export { LinearProvider } from './linear.js';
+/**
+ * Get the appropriate issue provider for a project.
+ * Returns null if issue tracking is disabled.
+ */
+export function getProvider(project) {
+    const config = project.issueProvider ?? { type: 'github' };
+    switch (config.type) {
+        case 'github':
+            return new GitHubProvider(project.livestock ?? []);
+        case 'linear':
+            return new LinearProvider(config.teamId, config.teamName);
+        case 'none':
+            return null;
+    }
+}
+/**
+ * Check if a project has issue tracking enabled.
+ */
+export function hasIssueTracking(project) {
+    const config = project.issueProvider ?? { type: 'github' };
+    return config.type !== 'none';
+}

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

@@ -0,0 +1,24 @@
+import type { Issue, FetchIssuesOptions, LinearProviderInterface, LinearTeam, LinearCycle, LinearAssignee } from './types.js';
+export declare class LinearProvider implements LinearProviderInterface {
+    readonly type: "linear";
+    private teamId?;
+    private teamName?;
+    private cachedUserId?;
+    private cachedActiveCycleId?;
+    constructor(teamId?: string, teamName?: string);
+    isAuthenticated(): Promise<boolean>;
+    authenticate(): Promise<void>;
+    needsTeamSelection(): boolean;
+    fetchTeams(): Promise<LinearTeam[]>;
+    setTeamId(teamId: string): void;
+    setTeamName(teamName: string): void;
+    getTeamName(): string | undefined;
+    fetchTeamName(): Promise<string | undefined>;
+    getCurrentUserId(): Promise<string | null>;
+    fetchCycles(): Promise<LinearCycle[]>;
+    getActiveCycleId(): string | undefined;
+    fetchAssignees(): Promise<LinearAssignee[]>;
+    fetchIssues(options?: FetchIssuesOptions): Promise<Issue[]>;
+    getIssue(id: string): Promise<Issue>;
+    private normalizeIssue;
+}

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,8 +1,11 @@
 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;
+export declare const SIGNALS_DIR: string;
+export declare const HOOKS_DIR: string;
 export declare function getProjectPath(name: string): string;
 export declare function getBarnPath(name: string): string;
 export declare function getSessionPath(id: string): string;

package/dist/lib/paths.js

@@ -2,9 +2,12 @@ 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');
+export const SIGNALS_DIR = join(YEEHAW_DIR, 'session-signals');
+export const HOOKS_DIR = join(YEEHAW_DIR, 'bin');
 /**
  * Validate a name to prevent path traversal attacks.
  * Rejects names containing path separators or parent directory references.