@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/hooks.js

@@ -1,226 +0,0 @@
-/**
- * haystack hooks - Install and manage git hooks for AI agent quality checks
- *
- * Installs:
- *   - Pre-commit hook (agent detection, truncation checking, LLM rules review)
- *   - Git hooks for Haystack quality checks and workflow guidance
- */
-import chalk from 'chalk';
-import { existsSync, accessSync, constants, lstatSync, readFileSync, readdirSync } from 'fs';
-import * as path from 'path';
-import { execFileSync, execSync } from 'child_process';
-import { findGitRoot, copyHookFiles, installHookDeps, copyLlmRulesTemplate, listHookInstallFiles, } from '../utils/hooks.js';
-function gitOutput(gitRoot, args) {
-    return execFileSync('git', args, { cwd: gitRoot, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-}
-function configuredHooksPath(gitRoot) {
-    try {
-        return gitOutput(gitRoot, ['config', '--get', 'core.hooksPath']);
-    }
-    catch (error) {
-        // `git config --get` exits 1 when the key is unset.
-        if (error.status === 1)
-            return undefined;
-        throw error;
-    }
-}
-/**
- * Everything `haystack hooks install` would change that Haystack did not
- * itself put there: hook files in hooks/ whose content differs from what this
- * CLI installs, and a core.hooksPath change (including one that silences
- * hooks already active in .git/hooks). Empty means installing is safe.
- */
-export async function describeHookOverwrites(gitRoot) {
-    const changes = [];
-    const hooksDir = path.join(gitRoot, 'hooks');
-    if (existsSync(hooksDir)) {
-        for (const file of await listHookInstallFiles()) {
-            const dest = path.join(hooksDir, file.rel);
-            let stat;
-            try {
-                stat = lstatSync(dest);
-            }
-            catch (error) {
-                if (error.code === 'ENOENT')
-                    continue;
-                throw error;
-            }
-            if (!stat.isFile() || !readFileSync(dest).equals(readFileSync(file.src))) {
-                changes.push(`overwrite hooks/${file.rel}`);
-            }
-        }
-    }
-    const hooksPath = configuredHooksPath(gitRoot);
-    if (hooksPath === undefined) {
-        const gitHooksDir = path.resolve(gitRoot, gitOutput(gitRoot, ['rev-parse', '--git-path', 'hooks']));
-        const active = existsSync(gitHooksDir)
-            ? readdirSync(gitHooksDir).filter(name => !name.endsWith('.sample')).sort()
-            : [];
-        if (active.length > 0) {
-            changes.push(`set core.hooksPath to "hooks", so git stops running ${active.map(name => `.git/hooks/${name}`).join(', ')}`);
-        }
-    }
-    else if (hooksPath !== 'hooks') {
-        changes.push(`change core.hooksPath from "${hooksPath}" to "hooks"`);
-    }
-    return changes;
-}
-export async function hooksInstall(options) {
-    console.log(chalk.cyan('\nHaystack Hooks Setup\n'));
-    // Step 1: Validate git repo
-    const gitRoot = findGitRoot();
-    if (!gitRoot) {
-        console.error(chalk.red('Not a git repository. Run this from inside a git repo.\n'));
-        process.exit(1);
-    }
-    const hooksDir = path.join(gitRoot, 'hooks');
-    // Step 2: Refuse to replace anything Haystack did not install unless forced.
-    const overwrites = await describeHookOverwrites(gitRoot);
-    if (overwrites.length > 0 && !options.force) {
-        console.error(chalk.yellow('Installing Haystack hooks would:'));
-        for (const change of overwrites)
-            console.error(chalk.yellow(`  - ${change}`));
-        console.error(chalk.yellow('Use --force to proceed.\n'));
-        process.exit(1);
-    }
-    if (overwrites.length > 0) {
-        console.log(chalk.yellow('Overwriting existing hooks...'));
-    }
-    // Step 3: Copy hook files
-    try {
-        await copyHookFiles(hooksDir);
-        console.log(chalk.green('✓ Hook scripts installed to hooks/'));
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Failed to copy hook files: ${message}\n`));
-        process.exit(1);
-    }
-    // Step 4: Install hook dependencies
-    console.log(chalk.dim('Installing hook dependencies (tree-sitter)...'));
-    try {
-        await installHookDeps(hooksDir);
-        console.log(chalk.green('✓ Hook dependencies installed'));
-    }
-    catch {
-        console.log(chalk.yellow('⚠ Failed to install hook dependencies. Run `npm ci` in hooks/ manually.'));
-    }
-    // Step 5: Configure git hooks path
-    try {
-        execSync('git config core.hooksPath hooks', { cwd: gitRoot, stdio: 'pipe' });
-        console.log(chalk.green('✓ Git configured to use hooks/ directory'));
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(chalk.red(`Failed to set git hooks path: ${message}\n`));
-        process.exit(1);
-    }
-    // Step 6: Create LLM_RULES.md if needed
-    try {
-        const created = await copyLlmRulesTemplate(gitRoot);
-        if (created) {
-            console.log(chalk.green('✓ Created LLM_RULES.md (customize this for your project)'));
-        }
-        else {
-            console.log(chalk.dim('  LLM_RULES.md already exists'));
-        }
-    }
-    catch {
-        console.log(chalk.yellow('⚠ Failed to create LLM_RULES.md'));
-    }
-    // Summary
-    console.log(chalk.green('\n✓ Haystack hooks installed!\n'));
-    console.log(chalk.dim('Hooks installed:'));
-    console.log(chalk.dim('  pre-commit           Agent detection, truncation check, LLM rules review'));
-    console.log(chalk.dim('  commit-msg           Haystack commit checks'));
-    console.log(chalk.dim('  post-commit          Haystack post-commit checks'));
-    console.log(chalk.dim('  pre-push             Haystack workflow guidance'));
-    console.log(chalk.dim('  prepare-commit-msg   Haystack commit preparation'));
-    console.log('');
-    console.log(chalk.dim('Files to commit:'));
-    console.log(chalk.dim('  hooks/               Hook scripts and TypeScript modules'));
-    console.log(chalk.dim('  LLM_RULES.md         Customize this for your project'));
-    console.log('');
-}
-// ============================================================================
-// haystack hooks status
-// ============================================================================
-export async function hooksStatus() {
-    const gitRoot = findGitRoot();
-    if (!gitRoot) {
-        console.error(chalk.red('Not a git repository.\n'));
-        process.exit(1);
-    }
-    console.log(chalk.cyan('\nHaystack Hooks Status\n'));
-    const hooksDir = path.join(gitRoot, 'hooks');
-    // Check hooks directory
-    if (!existsSync(hooksDir)) {
-        console.log(chalk.red('✗ hooks/ directory not found'));
-        console.log(chalk.dim('  Run: haystack hooks install\n'));
-        return;
-    }
-    console.log(chalk.green('✓ hooks/ directory exists'));
-    // Check each hook script
-    const requiredHooks = [
-        'pre-commit',
-        'commit-msg',
-        'post-commit',
-        'pre-push',
-        'prepare-commit-msg',
-    ];
-    for (const hook of requiredHooks) {
-        const hookPath = path.join(hooksDir, hook);
-        if (existsSync(hookPath)) {
-            try {
-                accessSync(hookPath, constants.X_OK);
-                console.log(chalk.green(`✓ ${hook}`));
-            }
-            catch {
-                console.log(chalk.yellow(`⚠ ${hook} (not executable)`));
-            }
-        }
-        else {
-            console.log(chalk.red(`✗ ${hook} missing`));
-        }
-    }
-    // Check TypeScript modules
-    const agentContextDir = path.join(hooksDir, 'agent-context');
-    const truncationDir = path.join(hooksDir, 'truncation-checker');
-    console.log(existsSync(agentContextDir)
-        ? chalk.green('✓ agent-context/ module')
-        : chalk.red('✗ agent-context/ missing'));
-    console.log(existsSync(truncationDir)
-        ? chalk.green('✓ truncation-checker/ module')
-        : chalk.red('✗ truncation-checker/ missing'));
-    // Check hook dependencies
-    const nodeModules = path.join(hooksDir, 'node_modules');
-    console.log(existsSync(nodeModules)
-        ? chalk.green('✓ Hook dependencies installed')
-        : chalk.yellow('⚠ Hook dependencies not installed (run npm ci in hooks/)'));
-    // Check git core.hooksPath
-    try {
-        const hooksPath = execSync('git config core.hooksPath', {
-            cwd: gitRoot,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        if (hooksPath === 'hooks') {
-            console.log(chalk.green('✓ Git core.hooksPath = hooks'));
-        }
-        else {
-            console.log(chalk.yellow(`⚠ Git core.hooksPath = ${hooksPath} (expected: hooks)`));
-        }
-    }
-    catch {
-        console.log(chalk.red('✗ Git core.hooksPath not set'));
-    }
-    // Check LLM_RULES.md
-    const rulesPath = path.join(gitRoot, 'LLM_RULES.md');
-    if (existsSync(rulesPath)) {
-        console.log(chalk.green('✓ LLM_RULES.md'));
-    }
-    else {
-        console.log(chalk.yellow('⚠ LLM_RULES.md not found'));
-    }
-    console.log('');
-}

package/dist/commands/inbox.js

@@ -1,137 +0,0 @@
-import chalk from 'chalk';
-import { loadToken } from '../utils/auth.js';
-import { fetchCliIdentity, fetchGitHubJson, fetchHaystackInstallations, haystackJson, } from '../utils/haystack-api.js';
-import { withSchema } from '../schema.js';
-async function fetchOpenPulls(owner, repo, token) {
-    const pulls = [];
-    for (let page = 1;; page++) {
-        const batch = await fetchGitHubJson(`/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls?state=open&per_page=100&page=${page}`, token);
-        pulls.push(...batch);
-        if (batch.length < 100)
-            return pulls;
-    }
-}
-export function isRelevantToUser(pr, userId) {
-    return pr.user.id === userId
-        || (pr.assignees ?? []).some((user) => user.id === userId)
-        || (pr.requested_reviewers ?? []).some((user) => user.id === userId);
-}
-async function mapConcurrent(values, concurrency, fn) {
-    const results = new Array(values.length);
-    let next = 0;
-    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
-        while (next < values.length) {
-            const index = next++;
-            results[index] = await fn(values[index]);
-        }
-    }));
-    return results;
-}
-export function classify(candidate, analysis) {
-    const findingCount = analysis?.findingsCount ?? 0;
-    const failedChecks = analysis?.merge?.blocking_checks ?? [];
-    if (analysis?.analysisStatus === 'error') {
-        return {
-            bucket: 'needs_shepherding',
-            reason: 'Haystack analysis failed.',
-            action: 'Retry the analysis or inspect the failure.',
-        };
-    }
-    if (!analysis || analysis.analysisStatus === 'pending' || analysis.analysisStatus === 'in_queue') {
-        return {
-            bucket: 'analyzing',
-            reason: 'Haystack is still analyzing this PR.',
-            action: 'Wait for analysis to complete.',
-        };
-    }
-    if (analysis.analysisVerdict === 'has-issues' || (analysis.haystackRating ?? 5) < 4) {
-        return {
-            bucket: 'needs_shepherding',
-            reason: findingCount > 0
-                ? `Haystack found ${findingCount} author-actionable finding${findingCount === 1 ? '' : 's'}.`
-                : 'Haystack found author-actionable issues.',
-            action: 'Read the triage findings and resolve the issues.',
-        };
-    }
-    if (failedChecks.length > 0 || analysis.merge?.status === 'blocked') {
-        return {
-            bucket: 'needs_shepherding',
-            reason: failedChecks.length > 0
-                ? `${failedChecks.length} required check${failedChecks.length === 1 ? ' is' : 's are'} failing: ${failedChecks.join(', ')}.`
-                : (analysis.merge?.reason ?? 'The PR is blocked from merging.'),
-            action: analysis.merge?.action ?? 'Resolve the merge blockers.',
-        };
-    }
-    if (analysis.analysisVerdict === 'needs-review' || analysis.needsHumanReview) {
-        return {
-            bucket: 'needs_review',
-            reason: 'Analysis is clean, but review policy requires a human reviewer.',
-            action: 'Complete or request the required review.',
-        };
-    }
-    return {
-        bucket: 'good_to_merge',
-        reason: 'Haystack found no blocking issues.',
-        action: 'No user action is required.',
-    };
-}
-export async function fetchInboxPayload(token) {
-    const [identity, installations] = await Promise.all([
-        fetchCliIdentity(token),
-        fetchHaystackInstallations(token),
-    ]);
-    const repos = [...new Set(installations.flatMap((i) => i.repositories ?? []).map((r) => r.full_name))];
-    const batches = await mapConcurrent(repos, 8, async (fullName) => {
-        const [owner, repo] = fullName.split('/');
-        if (!owner || !repo)
-            throw new Error(`Invalid repository returned by Haystack: ${fullName}`);
-        const pulls = await fetchOpenPulls(owner, repo, token);
-        return pulls
-            .filter((pr) => isRelevantToUser(pr, identity.id))
-            .map((pr) => ({ ...pr, owner, repo }));
-    });
-    const candidates = batches.flat();
-    const refs = candidates.map((pr) => `${pr.owner}/${pr.repo}#${pr.number}`);
-    const analysis = refs.length === 0
-        ? {}
-        : await haystackJson('/api/bulk-analysis-summaries', token, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                prIdentifiers: refs,
-                prBaseBranches: Object.fromEntries(candidates.map((pr) => [`${pr.owner}/${pr.repo}#${pr.number}`, pr.base.ref])),
-                prHeadShas: Object.fromEntries(candidates.map((pr) => [`${pr.owner}/${pr.repo}#${pr.number}`, pr.head.sha])),
-            }),
-        });
-    return withSchema('inbox', {
-        pull_requests: candidates.map((pr) => {
-            const ref = `${pr.owner}/${pr.repo}#${pr.number}`;
-            return {
-                ref,
-                title: pr.title,
-                head_sha: pr.head.sha,
-                ...classify(pr, analysis[ref]),
-            };
-        }),
-    });
-}
-export async function inboxListCommand(options) {
-    const token = await loadToken();
-    if (!token)
-        throw new Error('Not authenticated. Run `haystack login` first.');
-    const payload = await fetchInboxPayload(token);
-    if (options.json) {
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-    }
-    if (payload.pull_requests.length === 0) {
-        console.log(chalk.dim('\nNo PRs need your attention.\n'));
-        return;
-    }
-    console.log(chalk.bold('\nHaystack inbox\n'));
-    for (const pr of payload.pull_requests) {
-        console.log(`${chalk.cyan(pr.ref)}  ${chalk.bold(pr.title)}`);
-        console.log(`  ${pr.reason}`);
-        console.log(`  ${chalk.dim('Next:')} ${pr.action}\n`);
-    }
-}

package/dist/commands/mcp.js

@@ -1,201 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { fetchInboxPayload } from './inbox.js';
-import { fetchPrStatePayload } from './pr.js';
-import { fetchPrStatusPayload } from './pr-status.js';
-import { fetchTriagePayload, fetchTriageHeadSha } from './triage.js';
-import { fetchAskPayload } from './ask.js';
-import { performOverride, performUndismiss } from './dismiss.js';
-import { performRequestReview } from './request-review.js';
-import { loadToken } from '../utils/auth.js';
-import { triggerAnalysis } from '../utils/analysis-api.js';
-import { parsePrRef } from '../utils/pr-ref.js';
-import { SCHEMA_VERSIONS } from '../schema.js';
-import { withSchema } from '../schema.js';
-const refInput = {
-    type: 'string',
-    description: 'PR reference: bare number, owner/repo#number, or GitHub URL.',
-};
-const TOOLS = [
-    {
-        name: 'inbox_list',
-        description: 'List PRs in the user\'s Haystack inbox with the reason and next action.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'pr_get',
-        description: 'Get useful state for one PR: triage, minimal merge blockers, and conditional fixer outcome.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'triage_get',
-        description: 'Get the complete Haystack verdict and every customer-facing finding for one PR.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'ask_haystack',
-        description: 'Ask Haystack about a PR. Returns the answer and every customer-facing source consulted.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ref: refInput,
-                question: { type: 'string', description: 'Question about the pull request.' },
-                session_id: { type: 'string', description: 'Optional prior Ask session to continue.' },
-            },
-            required: ['ref', 'question'],
-        },
-    },
-    {
-        name: 'pr_status',
-        description: 'Get which Haystack feed bucket a PR is in (analyzing, good_to_merge, issues, needs_assignment, ...) and why.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'dismiss',
-        description: 'Dismiss analysis findings for a PR (moves it toward "Good to Merge"). Tied to the current head commit; a new commit invalidates it.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'mark_reviewed',
-        description: 'Mark human review as not needed for a PR (moves it toward "Good to Merge"). Tied to the current head commit.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'undismiss',
-        description: 'Undo dismiss/mark-reviewed overrides for a PR, returning it to its original feed bucket.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'request_review',
-        description: 'Tag a PR as needing HUMAN review (adds haystack:needs-review), optionally requesting a specific GitHub user.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                ref: refInput,
-                reviewer: { type: 'string', description: 'Optional GitHub username to request review from.' },
-            },
-            required: ['ref'],
-        },
-    },
-    {
-        name: 'trigger_review',
-        description: 'Trigger a fresh Haystack MACHINE analysis of a PR\'s current head (equivalent to `haystack review`). Returns immediately; poll triage_get for results.',
-        inputSchema: { type: 'object', properties: { ref: refInput }, required: ['ref'] },
-    },
-    {
-        name: 'schema',
-        description: 'Return the committed JSON Schema for a Haystack machine response.',
-        inputSchema: {
-            type: 'object',
-            properties: { name: { type: 'string', enum: Object.keys(SCHEMA_VERSIONS) } },
-            required: ['name'],
-        },
-    },
-];
-async function readSchema(name) {
-    const major = SCHEMA_VERSIONS[name].split('.')[0];
-    const here = dirname(fileURLToPath(import.meta.url));
-    return JSON.parse(readFileSync(join(here, '..', '..', 'schemas', `${name}.v${major}.json`), 'utf8'));
-}
-export async function runMcpServer() {
-    const server = new Server({ name: 'haystack-cli', version: '1.0.0' }, { capabilities: { tools: {} } });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        const input = (args ?? {});
-        const ok = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] });
-        const fail = (message) => ({ isError: true, content: [{ type: 'text', text: message }] });
-        try {
-            if (name === 'inbox_list') {
-                const token = await loadToken();
-                if (!token)
-                    return fail('Not authenticated. Run `haystack login` first.');
-                return ok(await fetchInboxPayload(token));
-            }
-            if (name === 'pr_get') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(await fetchPrStatePayload(input.ref));
-            }
-            if (name === 'triage_get') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(await fetchTriagePayload(input.ref));
-            }
-            if (name === 'ask_haystack') {
-                if (typeof input.ref !== 'string' || typeof input.question !== 'string')
-                    return fail('ref and question required');
-                return ok(await fetchAskPayload(input.ref, input.question, {
-                    session: typeof input.session_id === 'string' ? input.session_id : undefined,
-                }));
-            }
-            if (name === 'pr_status') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(await fetchPrStatusPayload(input.ref));
-            }
-            if (name === 'dismiss' || name === 'mark_reviewed') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(withSchema('action', await performOverride(input.ref, name === 'dismiss' ? 'findings-dismissed' : 'review-not-needed', name === 'dismiss' ? 'dismiss' : 'mark-reviewed')));
-            }
-            if (name === 'undismiss') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(withSchema('action', await performUndismiss(input.ref)));
-            }
-            if (name === 'request_review') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                return ok(withSchema('action', await performRequestReview(input.ref, typeof input.reviewer === 'string' ? input.reviewer : undefined)));
-            }
-            if (name === 'trigger_review') {
-                if (typeof input.ref !== 'string')
-                    return fail('ref required');
-                const pr = parsePrRef(input.ref, 'review');
-                const token = await loadToken({ owner: pr.owner, repo: pr.repo });
-                if (!token)
-                    return fail('Not authenticated. Run `haystack login` first.');
-                const ref = `${pr.owner}/${pr.repo}#${pr.prNumber}`;
-                // Resolve the current head so ingestion's dedup compares commits — an
-                // in-flight run for an OLDER head must be superseded, not reused
-                // (same degradation as `haystack review`: continue head-less on failure).
-                let headSha;
-                try {
-                    headSha = await fetchTriageHeadSha(pr, token) ?? undefined;
-                }
-                catch {
-                    headSha = undefined;
-                }
-                const trigger = await triggerAnalysis(pr.owner, pr.repo, pr.prNumber, token, headSha);
-                if (trigger.status !== 'started' && trigger.status !== 'already_processing') {
-                    return fail(trigger.message);
-                }
-                return ok(withSchema('action', {
-                    action: 'trigger_review',
-                    status: 'ok',
-                    ref,
-                    detail: 'Analysis triggered; poll triage_get for results.',
-                    request_id: trigger.requestId,
-                    run_status: trigger.status,
-                    next: null,
-                }));
-            }
-            if (name === 'schema') {
-                const schema = input.name;
-                if (!(schema in SCHEMA_VERSIONS))
-                    return fail(`unknown schema; choose one of ${Object.keys(SCHEMA_VERSIONS).join(', ')}`);
-                return ok(await readSchema(schema));
-            }
-            return fail(`unknown tool: ${name}`);
-        }
-        catch (error) {
-            return fail(error instanceof Error ? error.message : String(error));
-        }
-    });
-    await server.connect(new StdioServerTransport());
-}