@colmbus72/yeehaw 0.5.0 → 0.6.0

package/dist/lib/context.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Build a context string to inject into Claude sessions spawned from Yeehaw.
+ * Includes project name and wiki section titles (not content) to hint at available context.
+ */
+export declare function buildProjectContext(projectName: string): string | null;
+/**
+ * Build context for a livestock-specific session.
+ * Includes project context plus livestock details.
+ */
+export declare function buildLivestockContext(projectName: string, livestockName: string): string | null;

package/dist/lib/context.js

@@ -0,0 +1,63 @@
+import { loadProject } from './config.js';
+/**
+ * Build a context string to inject into Claude sessions spawned from Yeehaw.
+ * Includes project name and wiki section titles (not content) to hint at available context.
+ */
+export function buildProjectContext(projectName) {
+    const project = loadProject(projectName);
+    if (!project) {
+        return null;
+    }
+    const lines = [];
+    lines.push(`You are working on the "${project.name}" project.`);
+    if (project.summary) {
+        lines.push(`Project: ${project.summary}`);
+    }
+    // Add wiki section titles as hints
+    const wikiSections = project.wiki || [];
+    if (wikiSections.length > 0) {
+        lines.push('');
+        lines.push('Yeehaw wiki sections available:');
+        for (const section of wikiSections) {
+            lines.push(`- ${section.title}`);
+        }
+        lines.push('');
+        lines.push('Use mcp__yeehaw__get_wiki_section to fetch relevant context before making architectural decisions.');
+    }
+    return lines.join('\n');
+}
+/**
+ * Build context for a livestock-specific session.
+ * Includes project context plus livestock details.
+ */
+export function buildLivestockContext(projectName, livestockName) {
+    const project = loadProject(projectName);
+    if (!project) {
+        return null;
+    }
+    const livestock = project.livestock?.find(l => l.name === livestockName);
+    if (!livestock) {
+        return buildProjectContext(projectName);
+    }
+    const lines = [];
+    lines.push(`You are working on the "${project.name}" project, in the "${livestock.name}" environment.`);
+    if (project.summary) {
+        lines.push(`Project: ${project.summary}`);
+    }
+    // Add livestock details
+    if (livestock.branch) {
+        lines.push(`Branch: ${livestock.branch}`);
+    }
+    // Add wiki section titles as hints
+    const wikiSections = project.wiki || [];
+    if (wikiSections.length > 0) {
+        lines.push('');
+        lines.push('Yeehaw wiki sections available:');
+        for (const section of wikiSections) {
+            lines.push(`- ${section.title}`);
+        }
+        lines.push('');
+        lines.push('Use mcp__yeehaw__get_wiki_section to fetch relevant context before making architectural decisions.');
+    }
+    return lines.join('\n');
+}

package/dist/lib/critters.d.ts

@@ -26,3 +26,36 @@ export declare function discoverCritters(barn: Barn): Promise<{
     critters: DiscoveredCritter[];
     error?: string;
 }>;
+/**
+ * Service info from systemctl
+ */
+export interface SystemService {
+    name: string;
+    state: 'running' | 'stopped' | 'unknown';
+    description?: string;
+}
+/**
+ * List systemd services on a barn
+ * @param barn - The barn to query
+ * @param activeOnly - If true, only return running services (default: true)
+ */
+export declare function listSystemServices(barn: Barn, activeOnly?: boolean): Promise<{
+    services: SystemService[];
+    error?: string;
+}>;
+/**
+ * Details extracted from a systemd service file
+ */
+export interface ServiceDetails {
+    service_path: string;
+    config_path?: string;
+    log_path?: string;
+    use_journald: boolean;
+}
+/**
+ * Get details about a systemd service by parsing its unit file
+ */
+export declare function getServiceDetails(barn: Barn, serviceName: string): Promise<{
+    details?: ServiceDetails;
+    error?: string;
+}>;

package/dist/lib/critters.js

@@ -199,3 +199,167 @@ export async function discoverCritters(barn) {
     }
     return { critters: discovered };
 }
+/**
+ * List systemd services on a barn
+ * @param barn - The barn to query
+ * @param activeOnly - If true, only return running services (default: true)
+ */
+export async function listSystemServices(barn, activeOnly = true) {
+    // For active only: list-units shows running services
+    // For all: list-unit-files shows all installed services
+    const cmd = activeOnly
+        ? 'systemctl list-units --type=service --state=running --no-pager --no-legend'
+        : 'systemctl list-unit-files --type=service --no-pager --no-legend';
+    let output;
+    // Local barn
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', cmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { services: [], error: `Failed to list services: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        // Remote barn - SSH
+        if (!barn.host || !barn.user) {
+            return { services: [], error: `Barn '${barn.name}' is not configured for SSH` };
+        }
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), cmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { services: [], error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    const services = [];
+    const lines = output.split('\n').filter(line => line.trim());
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 1)
+            continue;
+        const serviceName = parts[0];
+        if (!serviceName.endsWith('.service'))
+            continue;
+        if (activeOnly) {
+            // list-units format: UNIT LOAD ACTIVE SUB DESCRIPTION...
+            services.push({
+                name: serviceName,
+                state: 'running',
+                description: parts.slice(4).join(' ') || undefined,
+            });
+        }
+        else {
+            // list-unit-files format: UNIT STATE PRESET
+            const stateStr = parts[1]?.toLowerCase() || '';
+            services.push({
+                name: serviceName,
+                state: stateStr === 'enabled' ? 'unknown' : 'stopped',
+            });
+        }
+    }
+    return { services };
+}
+/**
+ * Get details about a systemd service by parsing its unit file
+ */
+export async function getServiceDetails(barn, serviceName) {
+    // Get the unit file path
+    const pathCmd = `systemctl show -p FragmentPath ${shellEscape(serviceName)} --value`;
+    let servicePath;
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', pathCmd]);
+            servicePath = result.stdout.trim();
+        }
+        catch (err) {
+            return { error: `Failed to get service path: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        if (!barn.host || !barn.user) {
+            return { error: `Barn '${barn.name}' is not configured for SSH` };
+        }
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), pathCmd]);
+            servicePath = result.stdout.trim();
+        }
+        catch (err) {
+            return { error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    if (!servicePath) {
+        return { error: 'Could not find service unit file' };
+    }
+    // Read the service file to extract details
+    const catCmd = `cat ${shellEscape(servicePath)}`;
+    let serviceContent;
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', catCmd]);
+            serviceContent = result.stdout;
+        }
+        catch (err) {
+            return { error: `Failed to read service file: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), catCmd]);
+            serviceContent = result.stdout;
+        }
+        catch (err) {
+            return { error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    // Parse the service file
+    let config_path;
+    let log_path;
+    let use_journald = true;
+    for (const line of serviceContent.split('\n')) {
+        const trimmed = line.trim();
+        // Look for ExecStart to find config flags
+        if (trimmed.startsWith('ExecStart=')) {
+            const execLine = trimmed.slice('ExecStart='.length);
+            // Common config flag patterns
+            const configPatterns = [
+                /--config[=\s]([^\s]+)/,
+                /--defaults-file[=\s]([^\s]+)/,
+                /-c\s+([^\s]+)/,
+                /--conf[=\s]([^\s]+)/,
+            ];
+            for (const pattern of configPatterns) {
+                const match = execLine.match(pattern);
+                if (match) {
+                    config_path = match[1];
+                    break;
+                }
+            }
+        }
+        // Check StandardOutput/StandardError for log paths
+        if (trimmed.startsWith('StandardOutput=') || trimmed.startsWith('StandardError=')) {
+            const value = trimmed.split('=')[1];
+            if (value && !value.startsWith('journal') && !value.startsWith('inherit')) {
+                // Could be file:path or append:path
+                const fileMatch = value.match(/(?:file|append):(.+)/);
+                if (fileMatch) {
+                    log_path = fileMatch[1];
+                    use_journald = false;
+                }
+            }
+        }
+    }
+    return {
+        details: {
+            service_path: servicePath,
+            config_path,
+            log_path,
+            use_journald,
+        },
+    };
+}

package/dist/lib/hotkeys.d.ts

@@ -1,4 +1,4 @@
-export type HotkeyScope = 'global' | 'global-dashboard' | 'project-context' | 'barn-context' | 'wiki-view' | 'issues-view' | 'livestock-detail' | 'logs-view' | 'night-sky' | 'list' | 'content';
+export type HotkeyScope = 'global' | 'global-dashboard' | 'project-context' | 'barn-context' | 'wiki-view' | 'issues-view' | 'livestock-detail' | 'logs-view' | 'critter-detail' | 'critter-logs' | 'night-sky' | 'list' | 'content';
 export type HotkeyCategory = 'navigation' | 'action' | 'system';
 export interface Hotkey {
     key: string;

package/dist/lib/hotkeys.js

@@ -31,12 +31,16 @@ export const HOTKEYS = [
     { key: 'w', description: 'Open wiki', category: 'action', scopes: ['project-context'] },
     { key: 'i', description: 'Open issues', category: 'action', scopes: ['project-context'] },
     // === LIVESTOCK DETAIL PAGE-LEVEL ===
-    { key: 'c', description: 'Claude session', category: 'action', scopes: ['livestock-detail'] },
+    { key: 'c', description: 'Claude session (local only)', category: 'action', scopes: ['livestock-detail'] },
     { key: 's', description: 'Shell session', category: 'action', scopes: ['livestock-detail'] },
     { key: 'l', description: 'View logs', category: 'action', scopes: ['livestock-detail'] },
+    // === CRITTER DETAIL PAGE-LEVEL ===
+    { key: 'l', description: 'View logs', category: 'action', scopes: ['critter-detail'] },
+    { key: 'e', description: 'Edit', category: 'action', scopes: ['critter-detail'] },
     // === ISSUES VIEW ===
-    { key: 'r', description: 'Refresh', category: 'action', scopes: ['issues-view', 'logs-view'] },
+    { key: 'r', description: 'Refresh', category: 'action', scopes: ['issues-view', 'logs-view', 'critter-logs'] },
     { key: 'o', description: 'Open in browser', category: 'action', scopes: ['issues-view'] },
+    { key: 'c', description: 'Open in Claude', category: 'action', scopes: ['issues-view'] },
     // === NIGHT SKY ===
     { key: 'v', description: 'Visualizer', category: 'navigation', scopes: ['global-dashboard'] },
     { key: 'c', description: 'Spawn cloud', category: 'action', scopes: ['night-sky'] },

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

@@ -0,0 +1,11 @@
+import type { Issue, IssueProvider, FetchIssuesOptions } from './types.js';
+import type { Livestock } from '../../types.js';
+export declare class GitHubProvider implements IssueProvider {
+    readonly type: "github";
+    private repos;
+    constructor(livestock: Livestock[]);
+    isAuthenticated(): Promise<boolean>;
+    authenticate(): Promise<void>;
+    fetchIssues(options?: FetchIssuesOptions): Promise<Issue[]>;
+    getIssue(id: string): Promise<Issue>;
+}

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;
+}