@bicorne/task-flow 0.1.0

package/dist/hooks/phase-gate-validator.js

@@ -0,0 +1,407 @@
+"use strict";
+/**
+ * hooks/phase-gate-validator.ts
+ * Validate phase transition gates
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.normalizeValidationName = normalizeValidationName;
+exports.getValidationAliases = getValidationAliases;
+exports.isPassedStatus = isPassedStatus;
+exports.parseReviewConclusion = parseReviewConclusion;
+exports.parseReviewValidationMap = parseReviewValidationMap;
+exports.parseReviewReport = parseReviewReport;
+exports.deriveTransitionFromFilePath = deriveTransitionFromFilePath;
+exports.getTaskFilePath = getTaskFilePath;
+exports.readTaskJson = readTaskJson;
+exports.getValidationItems = getValidationItems;
+exports.getPlanningSummary = getPlanningSummary;
+exports.getPlanningList = getPlanningList;
+exports.getSnapshotValidationMap = getSnapshotValidationMap;
+exports.hasValidationPassed = hasValidationPassed;
+exports.assessTransitionGate = assessTransitionGate;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../lib/config");
+const state_1 = require("../lib/state");
+const constants_1 = require("../lib/constants");
+function normalizePath(inputPath, projectRoot) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        return '';
+    }
+    const absolutePath = path.isAbsolute(inputPath) ? inputPath : path.resolve(projectRoot, inputPath);
+    return path.relative(projectRoot, absolutePath).replace(/\\/g, '/');
+}
+function normalizeValidationName(name) {
+    return String(name || '')
+        .trim()
+        .toLowerCase()
+        .replace(/_/g, '-')
+        .replace(/\s+/g, '-');
+}
+function getValidationAliases(validationName) {
+    const normalized = normalizeValidationName(validationName);
+    return constants_1.VALIDATION_ALIASES[normalized] || [normalized];
+}
+function isPassedStatus(status) {
+    if (!status) {
+        return false;
+    }
+    const normalized = status.trim().toLowerCase();
+    return constants_1.VALIDATED_STATUSES.includes(normalized);
+}
+function parseReviewConclusion(content) {
+    const patterns = [
+        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
+        { regex: /^##\s*结论\s*:\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /^##\s*结论\s*:\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /^##\s*结论\s*:\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
+        { regex: /^#\s*PASS\b/m, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /^#\s*NEEDS_WORK\b/m, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /^#\s*FAIL\b/m, result: constants_1.REVIEW_CONCLUSION.FAIL },
+        { regex: /\*\*结论\*\*\s*:\s*PASS\b/, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /\*\*结论\*\*\s*:\s*NEEDS_WORK\b/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /\*\*结论\*\*\s*:\s*FAIL\b/, result: constants_1.REVIEW_CONCLUSION.FAIL },
+        { regex: /\*\*PASS\*\*/, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /\*\*NEEDS_WORK\*\*/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /\*\*FAIL\*\*/, result: constants_1.REVIEW_CONCLUSION.FAIL },
+        // Additional pattern for "结论 : NEEDS_WORK" format (with space before colon)
+        { regex: /结论\s*:\s*NEEDS_WORK\b/, result: constants_1.REVIEW_CONCLUSION.NEEDS_WORK },
+        { regex: /结论\s*:\s*PASS\b/, result: constants_1.REVIEW_CONCLUSION.PASS },
+        { regex: /结论\s*:\s*FAIL\b/, result: constants_1.REVIEW_CONCLUSION.FAIL },
+    ];
+    for (const { regex, result } of patterns) {
+        if (regex.test(content)) {
+            return result;
+        }
+    }
+    return null;
+}
+function parseReviewValidationMap(content) {
+    const validationMap = {};
+    const regex = /^\s*[-*]?\s*([a-z][a-z0-9_-]*)\s*:\s*([A-Za-z0-9_-]+)\s*$/gm;
+    let match = regex.exec(content);
+    while (match) {
+        const key = match[1];
+        const value = match[2];
+        if (key && value) {
+            validationMap[normalizeValidationName(key)] = value;
+        }
+        match = regex.exec(content);
+    }
+    return validationMap;
+}
+function parseReviewReport(content) {
+    const conclusion = parseReviewConclusion(content);
+    const validationMap = parseReviewValidationMap(content);
+    if (conclusion && !validationMap['review-conclusion']) {
+        validationMap['review-conclusion'] = conclusion;
+    }
+    return {
+        conclusion,
+        validationMap,
+    };
+}
+function deriveTransitionFromFilePath(filePath, config) {
+    const relativePath = normalizePath(filePath, config.projectRoot);
+    // Security: Prevent path traversal by ensuring path doesn't escape expected directories
+    if (relativePath.includes('..') || (relativePath.startsWith('/') && !relativePath.startsWith(config.projectRoot))) {
+        return null;
+    }
+    // Check if path is in harness directory or matches expected patterns
+    const isInHarness = relativePath.includes('.harness/');
+    const matchesTaskPattern = new RegExp(`^${normalizePath(config.tasksDirAbs, config.projectRoot)}/.+\\.json$`).test(relativePath);
+    const matchesSnapshotPattern = new RegExp(`^${normalizePath(config.snapshotsDirAbs, config.projectRoot)}/.+\\.json$`).test(relativePath);
+    const matchesReportPattern = new RegExp(`^${normalizePath(config.reportsDirAbs, config.projectRoot)}/.+\\.md$`).test(relativePath);
+    if (!isInHarness && !matchesTaskPattern && !matchesSnapshotPattern && !matchesReportPattern) {
+        return null;
+    }
+    const tasksPattern = new RegExp(`^${normalizePath(config.tasksDirAbs, config.projectRoot)}/.+\\.json$`);
+    const snapshotPattern = new RegExp(`^${normalizePath(config.snapshotsDirAbs, config.projectRoot)}/.+\\.json$`);
+    const reportPattern = new RegExp(`^${normalizePath(config.reportsDirAbs, config.projectRoot)}/.+\\.md$`);
+    if (tasksPattern.test(relativePath)) {
+        return { phaseCompleted: 'planning', nextPhase: 'implementation', relativePath };
+    }
+    if (snapshotPattern.test(relativePath) && /-impl\.json$/.test(relativePath)) {
+        return { phaseCompleted: 'implementation', nextPhase: 'review', relativePath };
+    }
+    if (reportPattern.test(relativePath) && /-review\.md$/.test(relativePath)) {
+        return { phaseCompleted: 'review', nextPhase: 'merge', relativePath };
+    }
+    return null;
+}
+function getTaskFilePath(config, taskId) {
+    return path.resolve(config.tasksDirAbs, `${taskId}.json`);
+}
+function readTaskJson(config, taskId) {
+    const taskPath = getTaskFilePath(config, taskId);
+    if (!fs.existsSync(taskPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(taskPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function getValidationItems(taskJson, phaseName) {
+    if (!taskJson) {
+        return [];
+    }
+    if (phaseName === 'implementation') {
+        return Array.isArray(taskJson.validation?.commands) ? taskJson.validation.commands : [];
+    }
+    if (phaseName === 'review') {
+        return Array.isArray(taskJson.validation?.manual_checks) ? taskJson.validation.manual_checks : [];
+    }
+    return [];
+}
+function getPlanningSummary(taskJson) {
+    return taskJson?.implementation?.notes || '';
+}
+function getPlanningList(taskJson, key) {
+    if (!taskJson) {
+        return [];
+    }
+    if (key === 'implementationSteps') {
+        const steps = Array.isArray(taskJson.implementation?.steps) ? taskJson.implementation.steps : [];
+        return steps.map((item) => (typeof item === 'string' ? item : item.step || ''));
+    }
+    if (key === 'testStrategy') {
+        return Array.isArray(taskJson.validation?.commands) ? taskJson.validation.commands : [];
+    }
+    return [];
+}
+function getSnapshotValidationMap(snapshotPath) {
+    if (!snapshotPath || !fs.existsSync(snapshotPath)) {
+        return {};
+    }
+    try {
+        const snapshot = JSON.parse(fs.readFileSync(snapshotPath, 'utf8'));
+        const results = Array.isArray(snapshot.validationResults) ? snapshot.validationResults : [];
+        const map = {};
+        for (const result of results) {
+            if (!result?.name) {
+                continue;
+            }
+            const name = normalizeValidationName(result.name);
+            map[name] = isPassedStatus(result.status);
+        }
+        return map;
+    }
+    catch {
+        return {};
+    }
+}
+function hasValidationPassed(validationName, snapshotValidationMap) {
+    const candidates = getValidationAliases(validationName).map(normalizeValidationName);
+    return candidates.some((item) => snapshotValidationMap[item] === true || isPassedStatus(snapshotValidationMap[item]));
+}
+/**
+ * Validate planning phase
+ */
+function validatePlanningPhase(taskJson, validations, config) {
+    const missingValidations = [];
+    const details = [];
+    const taskOutput = taskJson.metadata?.outputs?.task;
+    const taskOutputExists = taskOutput && fs.existsSync(path.resolve(config.projectRoot, taskOutput));
+    if (!taskOutputExists) {
+        missingValidations.push('planning-task-exists');
+    }
+    if (validations.includes('planning-ready')) {
+        const summary = getPlanningSummary(taskJson);
+        const implementationSteps = getPlanningList(taskJson, 'implementationSteps');
+        const testStrategy = getPlanningList(taskJson, 'testStrategy');
+        if (!summary) {
+            missingValidations.push('planning.summary');
+        }
+        if (implementationSteps.length === 0) {
+            missingValidations.push('planning.implementationSteps');
+        }
+        if (testStrategy.length === 0) {
+            missingValidations.push('planning.testStrategy');
+        }
+    }
+    return { missingValidations, details };
+}
+/**
+ * Validate implementation phase
+ */
+function validateImplementationPhase(validations, relativePath, config) {
+    const missingValidations = [];
+    const details = [];
+    const snapshotPath = path.resolve(config.projectRoot, relativePath);
+    const snapshotValidationMap = getSnapshotValidationMap(snapshotPath);
+    for (const validation of validations) {
+        if (!hasValidationPassed(validation, snapshotValidationMap)) {
+            missingValidations.push(validation);
+        }
+    }
+    details.push(`snapshot:${relativePath}`);
+    return { missingValidations, details };
+}
+/**
+ * Validate review phase
+ */
+function validateReviewPhase(validations, relativePath, config, stateReviewConclusion) {
+    const missingValidations = [];
+    const details = [];
+    let reviewConclusion = stateReviewConclusion;
+    const reportPath = path.resolve(config.projectRoot, relativePath);
+    if (!fs.existsSync(reportPath)) {
+        missingValidations.push('review-report-exists');
+        return { missingValidations, details, reviewConclusion };
+    }
+    const reportContent = fs.readFileSync(reportPath, 'utf8');
+    const parsedReport = parseReviewReport(reportContent);
+    if (parsedReport.conclusion) {
+        reviewConclusion = parsedReport.conclusion;
+    }
+    for (const validation of validations) {
+        const normalizedValidation = normalizeValidationName(validation);
+        if (normalizedValidation === 'review-conclusion') {
+            if (reviewConclusion !== 'PASS') {
+                missingValidations.push('review-conclusion=PASS');
+            }
+            continue;
+        }
+        if (!hasValidationPassed(normalizedValidation, parsedReport.validationMap)) {
+            missingValidations.push(validation);
+        }
+    }
+    details.push(`report:${relativePath}`);
+    return { missingValidations, details, reviewConclusion };
+}
+/**
+ * Assess transition gate
+ * @param options - Options
+ * @returns Gate assessment result
+ */
+function assessTransitionGate(options) {
+    const { taskId, filePath, state, config } = options;
+    const transition = deriveTransitionFromFilePath(filePath, config);
+    if (!transition) {
+        return { allowed: false, skipped: true, reason: 'not-transition-artifact' };
+    }
+    const taskJson = readTaskJson(config, taskId);
+    if (!taskJson) {
+        return {
+            allowed: false,
+            skipped: false,
+            phaseCompleted: transition.phaseCompleted,
+            nextPhase: transition.nextPhase,
+            reason: `task-not-found:${normalizePath(getTaskFilePath(config, taskId), config.projectRoot)}`,
+        };
+    }
+    const validations = getValidationItems(taskJson, transition.phaseCompleted);
+    let missingValidations = [];
+    let details = [];
+    let reviewConclusion = state?.reviewConclusion || null;
+    if (transition.phaseCompleted === 'planning') {
+        const planningResult = validatePlanningPhase(taskJson, validations, config);
+        missingValidations = planningResult.missingValidations;
+        details = planningResult.details;
+    }
+    if (transition.phaseCompleted === 'implementation') {
+        const implResult = validateImplementationPhase(validations, transition.relativePath, config);
+        missingValidations = implResult.missingValidations;
+        details = implResult.details;
+    }
+    if (transition.phaseCompleted === 'review') {
+        const reviewResult = validateReviewPhase(validations, transition.relativePath, config, reviewConclusion);
+        missingValidations = reviewResult.missingValidations;
+        details = reviewResult.details;
+        reviewConclusion = reviewResult.reviewConclusion;
+    }
+    if (missingValidations.length > 0) {
+        return {
+            allowed: false,
+            skipped: false,
+            phaseCompleted: transition.phaseCompleted,
+            nextPhase: transition.nextPhase,
+            missingValidations,
+            details,
+            reviewConclusion,
+            reason: 'phase-validation-failed',
+        };
+    }
+    return {
+        allowed: true,
+        skipped: false,
+        phaseCompleted: transition.phaseCompleted,
+        nextPhase: transition.nextPhase,
+        validations,
+        details,
+        reviewConclusion,
+        reason: 'phase-validation-passed',
+    };
+}
+/**
+ * Main entry point for hook usage
+ */
+function main() {
+    const input = JSON.parse(process.argv[2] || '{}');
+    const filePath = input.tool_input?.file_path || input.tool_input?.path || '';
+    const config = (0, config_1.loadConfig)();
+    const state = (0, state_1.loadState)(config);
+    if (!state?.currentTask) {
+        process.exit(0);
+    }
+    const result = assessTransitionGate({ taskId: state.currentTask, filePath, state, config });
+    if (result.skipped) {
+        process.exit(0);
+    }
+    if (!result.allowed) {
+        console.error(`[PHASE-GATE] blocked ${result.phaseCompleted} -> ${result.nextPhase}: ${result.reason}`);
+        if (Array.isArray(result.missingValidations) && result.missingValidations.length > 0) {
+            console.error(`[PHASE-GATE] missing: ${result.missingValidations.join(', ')}`);
+        }
+        process.exit(2);
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    assessTransitionGate,
+    deriveTransitionFromFilePath,
+    parseReviewConclusion,
+    parseReviewReport,
+};

package/dist/hooks/save-checkpoint.d.ts

@@ -0,0 +1,43 @@
+/**
+ * hooks/save-checkpoint.ts
+ * Save runtime snapshot/checkpoint
+ */
+import { Config } from '../lib/config';
+import { State } from '../lib/state';
+export interface HookInput {
+    hook_event_name?: string;
+    [key: string]: unknown;
+}
+export interface CheckpointResult {
+    saved: boolean;
+    reason?: string;
+    snapshotId?: string;
+    snapshotPath?: string;
+}
+export interface CheckpointOptions {
+    input: HookInput;
+    config: Config;
+    state: State;
+}
+export interface Snapshot {
+    snapshotId: string;
+    snapshotType: string;
+    taskId: string;
+    phase: string;
+    timestamp: string;
+    status: string;
+    source: string;
+    metrics: Record<string, unknown>;
+    files: string[];
+    validationResults: unknown[];
+}
+/**
+ * Save runtime snapshot
+ * @param options - Options
+ * @returns Result
+ */
+export declare function saveCheckpoint(options: CheckpointOptions): CheckpointResult;
+declare const _default: {
+    saveCheckpoint: typeof saveCheckpoint;
+};
+export default _default;

package/dist/hooks/save-checkpoint.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * hooks/save-checkpoint.ts
+ * Save runtime snapshot/checkpoint
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveCheckpoint = saveCheckpoint;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const state_1 = require("../lib/state");
+/**
+ * Validate config has required properties for checkpoint
+ */
+function validateConfigForCheckpoint(config) {
+    if (!config.projectRoot) {
+        return {
+            valid: false,
+            reason: 'missing-project-root',
+            message: 'Config missing projectRoot',
+        };
+    }
+    if (!config.snapshotsDirAbs) {
+        return {
+            valid: false,
+            reason: 'missing-snapshots-dir',
+            message: 'Config missing snapshotsDirAbs',
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Save runtime snapshot
+ * @param options - Options
+ * @returns Result
+ */
+function saveCheckpoint(options) {
+    const { input, config, state } = options;
+    const taskId = process.env.HARNESS_TASK_ID || state.currentTask;
+    const currentPhase = process.env.HARNESS_PHASE || state.currentPhase || 'unknown';
+    if (!taskId) {
+        return { saved: false, reason: 'missing-task-id' };
+    }
+    // Validate config before use
+    const configValidation = validateConfigForCheckpoint(config);
+    if (!configValidation.valid) {
+        console.error(`[SNAPSHOT] ${configValidation.message}`);
+        return { saved: false, reason: configValidation.reason || 'config-validation-failed' };
+    }
+    const projectRoot = config.projectRoot || process.cwd();
+    const snapshotDir = config.snapshotsDirAbs || path.resolve(projectRoot, '.harness', 'snapshots');
+    fs.mkdirSync(snapshotDir, { recursive: true });
+    const timestamp = Date.now();
+    const snapshotId = `${taskId}-${currentPhase}-${timestamp}`;
+    const snapshotRelativePath = path.posix.join(path.relative(projectRoot, snapshotDir), 'runtime', `${snapshotId}.json`);
+    const snapshot = {
+        snapshotId,
+        snapshotType: 'runtime',
+        taskId,
+        phase: currentPhase,
+        timestamp: new Date().toISOString(),
+        status: 'in_progress',
+        source: input.hook_event_name || 'runtime',
+        metrics: {},
+        files: [],
+        validationResults: [],
+    };
+    // Try to collect changed files from git diff
+    try {
+        const diffOutput = (0, child_process_1.execSync)('git diff --name-only HEAD', { encoding: 'utf8' });
+        snapshot.files = diffOutput.trim().split('\n').filter((f) => f);
+    }
+    catch {
+        // Git not available or no changes
+    }
+    // Save snapshot
+    const runtimeSnapshotDir = path.resolve(snapshotDir, 'runtime');
+    fs.mkdirSync(runtimeSnapshotDir, { recursive: true });
+    const snapshotPath = path.resolve(runtimeSnapshotDir, `${snapshotId}.json`);
+    fs.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2), 'utf8');
+    console.log(`[SNAPSHOT] Saved: ${snapshotId}`);
+    // Update state with current snapshot reference
+    (0, state_1.updateState)({
+        currentSnapshot: snapshotRelativePath,
+    }, config);
+    return {
+        saved: true,
+        snapshotId,
+        snapshotPath: snapshotRelativePath,
+    };
+}
+/**
+ * Main entry point for hook usage
+ */
+function main() {
+    const input = JSON.parse(process.argv[2] || '{}');
+    const config = (0, config_1.loadConfig)();
+    const state = (0, state_1.loadState)(config);
+    const result = saveCheckpoint({ input, config, state });
+    if (!result.saved) {
+        console.log(`[SNAPSHOT] skipped: ${result.reason}`);
+    }
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    saveCheckpoint,
+};

package/dist/hooks/start-mcp-servers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * hooks/start-mcp-servers.ts
+ * Hook for starting MCP servers with autoStart enabled
+ *
+ * This hook:
+ * 1. Gets MCP server configurations from context
+ * 2. Starts servers with lifecycle.autoStart = true
+ * 3. Returns connection information for downstream use
+ */
+import { McpServerConfig, StartResult, ConnectionInfo } from '../lib/mcp-client';
+export interface StartMcpContext {
+    config?: {
+        projectRoot: string;
+    };
+    tools?: {
+        mcp: McpServerConfig[];
+    };
+    [key: string]: unknown;
+}
+export interface StartMcpResult {
+    check: 'mcp-started';
+    success: boolean;
+    error?: string;
+    reason?: string;
+    message?: string;
+    result?: {
+        success: boolean;
+        results: StartResult[];
+    };
+    connectionInfo?: ConnectionInfo[];
+    started?: unknown[];
+    summary?: {
+        totalCount: number;
+        startedCount: number;
+        skippedCount: number;
+        failedCount: number;
+    };
+    stack?: string;
+}
+/**
+ * Start MCP servers hook
+ * @param context - Hook execution context
+ * @returns Hook execution result
+ */
+export declare function run(context: StartMcpContext): StartMcpResult;
+declare const _default: {
+    run: typeof run;
+    name: string;
+};
+export default _default;