@bicorne/task-flow 0.1.0

package/dist/commands/tasks-gen/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * commands/tasks-gen/types.ts
+ * Type definitions for task generation
+ */
+/**
+ * Task definition interface
+ */
+export interface Task {
+    id: string;
+    type: 'feat' | 'fix' | 'refactor' | 'test' | 'docs';
+    title: string;
+    priority: 'high' | 'medium' | 'low';
+    phase: number;
+    subphase?: number;
+    sequence?: number;
+    dependencies?: string[];
+    docs_to_read?: string[];
+    spec: {
+        description: string;
+        files: string[];
+        context?: string[];
+    };
+    acceptance_criteria?: string[];
+    implementation?: {
+        steps?: Array<{
+            step: string;
+            details?: string;
+        }>;
+        notes?: string;
+    };
+    validation?: {
+        commands?: string[];
+        manual_checks?: string[];
+    };
+    status: 'pending' | 'in_progress' | 'completed' | 'blocked';
+}
+/**
+ * Tasks generation options
+ */
+export interface TasksGenOptions {
+    cwd?: string;
+    change?: string;
+    type?: string;
+    priority?: string;
+    yes?: boolean;
+    input?: string;
+}
+/**
+ * Tasks generation result
+ */
+export interface TasksGenResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    changeName?: string;
+    tasksPath?: string;
+    tasksDir?: string;
+    manifestPath?: string;
+    generatedFiles?: string[];
+    totalTasks?: number;
+}
+/**
+ * Task schema constants
+ */
+export declare const TASK_SCHEMA: {
+    required: string[];
+    idPattern: RegExp;
+    types: string[];
+    priorities: string[];
+    statuses: string[];
+};

package/dist/commands/tasks-gen/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * commands/tasks-gen/types.ts
+ * Type definitions for task generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_SCHEMA = void 0;
+/**
+ * Task schema constants
+ */
+exports.TASK_SCHEMA = {
+    required: ['id', 'type', 'title', 'priority', 'phase', 'status', 'spec'],
+    idPattern: /^PHASE-[0-9]+-[0-9]+-[0-9]+$/,
+    types: ['feat', 'fix', 'refactor', 'test', 'docs'],
+    priorities: ['high', 'medium', 'low'],
+    statuses: ['pending', 'in_progress', 'completed', 'blocked'],
+};

package/dist/commands/tasks-gen/validators.d.ts

@@ -0,0 +1,14 @@
+/**
+ * commands/tasks-gen/validators.ts
+ * Validation utilities for task generation
+ */
+/**
+ * Validate required files exist
+ */
+export declare function validateRequiredFiles(paths: {
+    productRequirement: string;
+}): {
+    valid: boolean;
+    reason?: string;
+    message?: string;
+};

package/dist/commands/tasks-gen/validators.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * commands/tasks-gen/validators.ts
+ * Validation utilities for task generation
+ */
+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.validateRequiredFiles = validateRequiredFiles;
+const fs = __importStar(require("fs"));
+/**
+ * Validate required files exist
+ */
+function validateRequiredFiles(paths) {
+    if (!fs.existsSync(paths.productRequirement)) {
+        return {
+            valid: false,
+            reason: 'product-requirement-not-found',
+            message: `product-requirement.md not found: ${paths.productRequirement}`,
+        };
+    }
+    return { valid: true };
+}

package/dist/commands/tasks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * commands/tasks-gen.ts
+ * Backward-compatible re-export from tasks-gen/ module
+ * @deprecated Import from './tasks-gen/index' directly
+ */
+export { generateTasks, main, default } from './tasks-gen/index';
+export { Task, TasksGenOptions, TasksGenResult, TASK_SCHEMA } from './tasks-gen/types';
+export { parseTasksMd } from './tasks-gen/parsers';
+export { generatePhaseJson, generateManifestJson } from './tasks-gen/generators';

package/dist/commands/tasks.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * commands/tasks-gen.ts
+ * Backward-compatible re-export from tasks-gen/ module
+ * @deprecated Import from './tasks-gen/index' directly
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateManifestJson = exports.generatePhaseJson = exports.parseTasksMd = exports.TASK_SCHEMA = exports.default = exports.main = exports.generateTasks = void 0;
+var index_1 = require("./tasks-gen/index");
+Object.defineProperty(exports, "generateTasks", { enumerable: true, get: function () { return index_1.generateTasks; } });
+Object.defineProperty(exports, "main", { enumerable: true, get: function () { return index_1.main; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
+var types_1 = require("./tasks-gen/types");
+Object.defineProperty(exports, "TASK_SCHEMA", { enumerable: true, get: function () { return types_1.TASK_SCHEMA; } });
+var parsers_1 = require("./tasks-gen/parsers");
+Object.defineProperty(exports, "parseTasksMd", { enumerable: true, get: function () { return parsers_1.parseTasksMd; } });
+var generators_1 = require("./tasks-gen/generators");
+Object.defineProperty(exports, "generatePhaseJson", { enumerable: true, get: function () { return generators_1.generatePhaseJson; } });
+Object.defineProperty(exports, "generateManifestJson", { enumerable: true, get: function () { return generators_1.generateManifestJson; } });

package/dist/commands/worktree.d.ts

@@ -0,0 +1,28 @@
+/**
+ * commands/worktree.ts
+ * Create isolated git worktree for task execution
+ */
+export interface WorktreeOptions {
+    cwd?: string;
+    change?: string;
+    force?: boolean;
+    yes?: boolean;
+}
+export interface WorktreeResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    changeName?: string;
+    taskId?: string;
+    worktreeName?: string;
+    worktreePath?: string;
+    branchName?: string;
+    harnessLink?: string;
+}
+export declare function createWorktree(options?: WorktreeOptions): Promise<WorktreeResult>;
+export declare function main(): void;
+declare const _default: {
+    createWorktree: typeof createWorktree;
+    main: typeof main;
+};
+export default _default;

package/dist/commands/worktree.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * commands/worktree.ts
+ * Create isolated git worktree for task execution
+ */
+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.createWorktree = createWorktree;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../lib/config");
+const interactive_1 = require("../lib/interactive");
+function parseArgs(argv) {
+    const args = {};
+    for (let i = 2; i < argv.length; i += 1) {
+        const token = argv[i] || '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[i + 1] || '';
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+            continue;
+        }
+        args[key] = next;
+        i += 1;
+    }
+    return args;
+}
+function toChangeName(input) {
+    return String(input || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function getGitBranch(cwd) {
+    try {
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf8' }).trim();
+    }
+    catch {
+        return 'main';
+    }
+}
+/**
+ * Validate config has required properties for worktree creation
+ */
+function validateConfigForWorktree(config) {
+    if (!config.projectRoot) {
+        return {
+            valid: false,
+            reason: 'missing-project-root',
+            message: 'Config missing projectRoot',
+        };
+    }
+    if (!config.worktreesDirAbs) {
+        return {
+            valid: false,
+            reason: 'missing-worktrees-dir',
+            message: 'Config missing worktreesDirAbs',
+        };
+    }
+    return { valid: true };
+}
+async function createWorktree(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const changeName = toChangeName(options.change);
+    if (!changeName) {
+        return {
+            success: false,
+            reason: 'missing-change',
+            message: 'Missing required argument: --change <change-name>',
+        };
+    }
+    // Validate config before use
+    const configValidation = validateConfigForWorktree(config);
+    if (!configValidation.valid) {
+        return {
+            success: false,
+            reason: configValidation.reason,
+            message: configValidation.message || 'Unknown config validation error',
+        };
+    }
+    const projectRoot = config.projectRoot || process.cwd();
+    const specRoot = config.specRootAbs || path.resolve(projectRoot, 'spec');
+    const changeDir = path.resolve(specRoot, 'changes', changeName);
+    const manifestPath = path.resolve(changeDir, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        return {
+            success: false,
+            reason: 'manifest-not-found',
+            message: `manifest.json not found. Run 'task-flow tasks --change ${changeName}' first.`,
+        };
+    }
+    let manifestConfig;
+    try {
+        manifestConfig = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            reason: 'invalid-manifest',
+            message: `Failed to parse manifest.json: ${errorMessage}`,
+        };
+    }
+    const taskId = manifestConfig.taskId || changeName;
+    const taskType = manifestConfig.type || 'feat';
+    const worktreeName = `harness-${taskType}-${taskId}`;
+    const branchName = `${taskType}/${taskId}`;
+    const worktreesDir = config.worktreesDirAbs || path.resolve(projectRoot, '.worktrees');
+    const worktreePath = path.resolve(worktreesDir, worktreeName);
+    if (fs.existsSync(worktreePath)) {
+        return {
+            success: false,
+            reason: 'worktree-exists',
+            message: `Worktree already exists: ${worktreePath}. Use --force to recreate.`,
+        };
+    }
+    // Interactive confirmation
+    if (!options.yes) {
+        (0, interactive_1.printPreview)('Worktree Configuration', {
+            'Change Name': changeName,
+            'Task ID': taskId,
+            'Branch': branchName,
+            'Worktree Path': worktreePath,
+        });
+        const confirmed = await (0, interactive_1.confirm)({
+            message: 'Create worktree with above configuration?',
+            defaultYes: true,
+        });
+        if (!confirmed) {
+            return {
+                success: false,
+                reason: 'user-cancelled',
+                message: 'User cancelled the operation.',
+            };
+        }
+    }
+    try {
+        fs.mkdirSync(worktreesDir, { recursive: true });
+        const mainBranch = getGitBranch(projectRoot);
+        try {
+            (0, child_process_1.execSync)(`git worktree add "${worktreePath}" -b ${branchName} ${mainBranch}`, {
+                cwd: projectRoot,
+                stdio: 'pipe',
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (errorMessage.includes('already exists')) {
+                (0, child_process_1.execSync)(`git worktree add "${worktreePath}" ${branchName}`, {
+                    cwd: projectRoot,
+                    stdio: 'pipe',
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        const mainRepoRoot = projectRoot;
+        const harnessInWorktree = path.resolve(worktreePath, '.harness');
+        if (fs.existsSync(harnessInWorktree)) {
+            try {
+                fs.rmSync(harnessInWorktree, { recursive: true, force: true });
+            }
+            catch {
+                // ignore
+            }
+        }
+        try {
+            fs.symlinkSync(path.resolve(mainRepoRoot, '.harness'), harnessInWorktree, 'dir');
+        }
+        catch (symlinkError) {
+            const errorMessage = symlinkError instanceof Error ? symlinkError.message : 'Unknown error';
+            console.warn('[WORKTREE] Failed to create symlink for .harness:', errorMessage);
+            fs.mkdirSync(harnessInWorktree, { recursive: true });
+        }
+        const gitignorePath = path.resolve(worktreePath, '.gitignore');
+        let gitignoreContent = '';
+        if (fs.existsSync(gitignorePath)) {
+            gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+        }
+        if (!gitignoreContent.includes('.harness/')) {
+            const newContent = gitignoreContent.trim() + '\n\n# Harness\n.harness/\n';
+            fs.writeFileSync(gitignorePath, newContent, 'utf8');
+        }
+        return {
+            success: true,
+            changeName,
+            taskId,
+            worktreeName,
+            worktreePath,
+            branchName,
+            harnessLink: harnessInWorktree,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            success: false,
+            reason: 'git-error',
+            message: `Failed to create worktree: ${errorMessage}`,
+        };
+    }
+}
+function main() {
+    const args = parseArgs(process.argv);
+    createWorktree({
+        cwd: args.cwd,
+        change: args.change,
+        force: args.force === true,
+        yes: args.yes === true,
+    }).then((result) => {
+        if (!result.success) {
+            console.error(`[WORKTREE] ${result.message}`);
+            process.exit(1);
+        }
+        console.log('');
+        console.log('[WORKTREE] Worktree created successfully!');
+        console.log(`  Change Name: ${result.changeName}`);
+        console.log(`  Task ID: ${result.taskId}`);
+        console.log(`  Worktree: ${result.worktreePath}`);
+        console.log(`  Branch: ${result.branchName}`);
+        console.log(`  Harness Link: ${result.harnessLink}`);
+        console.log('');
+        console.log('Next steps:');
+        console.log(`  cd ${result.worktreePath}`);
+        console.log('  # Start implementing tasks');
+        console.log('');
+        process.exit(0);
+    });
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    createWorktree,
+    main,
+};

package/dist/hooks/check-prd-exists.d.ts

@@ -0,0 +1,20 @@
+/**
+ * hooks/check-prd-exists.ts
+ * Hook to check if product-requirement.md exists before generating design.md
+ */
+export interface CheckPrdExistsResult {
+    check: 'prd-exists';
+    exists: boolean;
+    path?: string;
+    reason?: string;
+}
+export interface CheckPrdExistsContext {
+    prdPath?: string;
+    [key: string]: unknown;
+}
+export declare function run(context: CheckPrdExistsContext): CheckPrdExistsResult;
+declare const _default: {
+    run: typeof run;
+    name: string;
+};
+export default _default;

package/dist/hooks/check-prd-exists.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * hooks/check-prd-exists.ts
+ * Hook to check if product-requirement.md exists before generating design.md
+ */
+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.run = run;
+const fs = __importStar(require("fs"));
+function run(context) {
+    const { prdPath } = context;
+    if (!prdPath) {
+        return {
+            check: 'prd-exists',
+            exists: false,
+            reason: 'missing-prd-path',
+        };
+    }
+    const exists = fs.existsSync(prdPath);
+    return {
+        check: 'prd-exists',
+        exists,
+        path: prdPath,
+    };
+}
+exports.default = {
+    run,
+    name: 'check-prd-exists',
+};

package/dist/hooks/check-worktree-conflict.d.ts

@@ -0,0 +1,34 @@
+/**
+ * hooks/check-worktree-conflict.ts
+ * Check for worktree conflicts to prevent multi-agent file conflicts
+ */
+import { Config } from '../lib/config';
+export interface HookInput {
+    tool_input?: {
+        file_path?: string;
+        path?: string;
+    };
+}
+export interface ConflictResult {
+    conflict: boolean;
+    reason?: string;
+    file?: string;
+    conflictingWorktree?: string;
+    message?: string;
+}
+export interface CheckOptions {
+    input: HookInput;
+    config: Config;
+    state?: unknown;
+}
+export declare function normalizePath(inputPath: string | undefined, projectRoot: string): string;
+/**
+ * Check for worktree conflicts
+ * @param options - Options
+ * @returns Result
+ */
+export declare function checkWorktreeConflict(options: CheckOptions): ConflictResult;
+declare const _default: {
+    checkWorktreeConflict: typeof checkWorktreeConflict;
+};
+export default _default;