@bicorne/task-flow 0.1.0

package/dist/lib/config.d.ts

@@ -0,0 +1,93 @@
+/**
+ * config.ts
+ * Configuration loader for task-flow
+ *
+ * Loads configuration from:
+ * 1. Environment variables (highest priority)
+ * 2. Config file (.harnessrc)
+ * 3. Default values (lowest priority)
+ */
+/**
+ * Default configuration values
+ */
+export declare const DEFAULTS: Config;
+/**
+ * Configuration object interface
+ */
+export interface Config {
+    harnessRoot?: string;
+    worktreesDir?: string;
+    tasksDir?: string;
+    snapshotsDir?: string;
+    archiveDir?: string;
+    reportsDir?: string;
+    plansDir?: string;
+    specRoot?: string;
+    configFile?: string;
+    harnessRootAbs?: string;
+    worktreesDirAbs?: string;
+    tasksDirAbs?: string;
+    snapshotsDirAbs?: string;
+    archiveDirAbs?: string;
+    reportsDirAbs?: string;
+    plansDirAbs?: string;
+    specRootAbs?: string;
+    projectRoot?: string;
+    configPath?: string;
+    configSources?: {
+        defaults: typeof DEFAULTS;
+        file: Record<string, unknown>;
+        env: Record<string, string>;
+    };
+}
+/**
+ * Find config file starting from cwd and walking up
+ * @param cwd - Current working directory
+ * @returns Path to config file or null
+ */
+export declare function findConfigFile(cwd: string): string | null;
+/**
+ * Load config from file
+ * @param configPath - Path to config file
+ * @returns Config object
+ */
+export declare function loadConfigFile(configPath: string | null): Record<string, unknown>;
+/**
+ * Load config from environment variables
+ * @returns Config object
+ */
+export declare function loadEnvConfig(): Record<string, string>;
+/**
+ * Resolve absolute path relative to project root
+ * @param basePath - Base path (can be relative or absolute)
+ * @param projectRoot - Project root directory
+ * @returns Resolved absolute path
+ */
+export declare function resolvePath(basePath: string | undefined, projectRoot: string): string;
+/**
+ * Load and merge all configuration sources
+ * @param options - Options
+ * @param options.cwd - Current working directory
+ * @param options.configFile - Explicit config file path
+ * @returns Merged configuration
+ */
+export declare function loadConfig(options?: {
+    cwd?: string;
+    configFile?: string;
+}): Config;
+/**
+ * Get a specific config value
+ * @param key - Config key
+ * @param defaultValue - Default value if not found
+ * @param options - Options
+ * @returns Config value
+ */
+export declare function getConfig<T = string>(key: string, defaultValue: T, options?: {
+    cwd?: string;
+    configFile?: string;
+}): T;
+/**
+ * Ensure all harness directories exist
+ * @param config - Config object
+ */
+export declare function ensureDirectories(config: Config): void;

package/dist/lib/config.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * config.ts
+ * Configuration loader for task-flow
+ *
+ * Loads configuration from:
+ * 1. Environment variables (highest priority)
+ * 2. Config file (.harnessrc)
+ * 3. Default values (lowest priority)
+ */
+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.DEFAULTS = void 0;
+exports.findConfigFile = findConfigFile;
+exports.loadConfigFile = loadConfigFile;
+exports.loadEnvConfig = loadEnvConfig;
+exports.resolvePath = resolvePath;
+exports.loadConfig = loadConfig;
+exports.getConfig = getConfig;
+exports.ensureDirectories = ensureDirectories;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Default configuration values
+ */
+exports.DEFAULTS = {
+    harnessRoot: '.harness',
+    worktreesDir: '.worktrees',
+    tasksDir: 'tasks',
+    snapshotsDir: 'snapshots',
+    archiveDir: 'archive',
+    reportsDir: 'reports',
+    plansDir: 'plans',
+    specRoot: 'spec',
+};
+/**
+ * Environment variable mappings
+ */
+const ENV_MAPPING = {
+    HARNESS_ROOT: 'harnessRoot',
+    HARNESS_WORKTREES_DIR: 'worktreesDir',
+    HARNESS_TASKS_DIR: 'tasksDir',
+    HARNESS_SNAPSHOTS_DIR: 'snapshotsDir',
+    HARNESS_ARCHIVE_DIR: 'archiveDir',
+    HARNESS_REPORTS_DIR: 'reportsDir',
+    HARNESS_PLANS_DIR: 'plansDir',
+    HARNESS_SPEC_ROOT: 'specRoot',
+    HARNESS_CONFIG_FILE: 'configFile',
+};
+/**
+ * Find config file starting from cwd and walking up
+ * @param cwd - Current working directory
+ * @returns Path to config file or null
+ */
+function findConfigFile(cwd) {
+    const configNames = ['.harnessrc', '.harnessrc.json', 'harness.config.json'];
+    let current = cwd;
+    while (current !== path.dirname(current)) {
+        for (const configName of configNames) {
+            const configPath = path.resolve(current, configName);
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        current = path.dirname(current);
+    }
+    // Check cwd for config file even if not found walking up
+    for (const configName of configNames) {
+        const configPath = path.resolve(cwd, configName);
+        if (fs.existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}
+/**
+ * Load config from file
+ * @param configPath - Path to config file
+ * @returns Config object
+ */
+function loadConfigFile(configPath) {
+    if (!configPath || !fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        // Support both JSON and JSONC (with comments)
+        const cleaned = content.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        return JSON.parse(cleaned);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.warn(`[CONFIG] Failed to load config file: ${configPath}`, errorMessage);
+        return {};
+    }
+}
+/**
+ * Load config from environment variables
+ * @returns Config object
+ */
+function loadEnvConfig() {
+    const config = {};
+    for (const [envVar, configKey] of Object.entries(ENV_MAPPING)) {
+        const envValue = process.env[envVar];
+        if (envValue) {
+            config[configKey] = envValue;
+        }
+    }
+    return config;
+}
+/**
+ * Resolve absolute path relative to project root
+ * @param basePath - Base path (can be relative or absolute)
+ * @param projectRoot - Project root directory
+ * @returns Resolved absolute path
+ */
+function resolvePath(basePath, projectRoot) {
+    if (!basePath) {
+        return projectRoot;
+    }
+    if (path.isAbsolute(basePath)) {
+        return basePath;
+    }
+    return path.resolve(projectRoot, basePath);
+}
+/**
+ * Load and merge all configuration sources
+ * @param options - Options
+ * @param options.cwd - Current working directory
+ * @param options.configFile - Explicit config file path
+ * @returns Merged configuration
+ */
+function loadConfig(options = {}) {
+    const cwd = path.resolve(options.cwd || process.cwd());
+    // Find config file
+    const configPath = options.configFile || findConfigFile(cwd);
+    // Determine project root
+    let projectRoot = cwd;
+    if (configPath) {
+        projectRoot = path.dirname(configPath);
+        // Walk up to find actual project root (where .git is)
+        let current = projectRoot;
+        while (current !== path.dirname(current)) {
+            if (fs.existsSync(path.resolve(current, '.git'))) {
+                projectRoot = current;
+                break;
+            }
+            current = path.dirname(current);
+        }
+    }
+    // Load from all sources
+    const fileConfig = configPath ? loadConfigFile(configPath) : {};
+    const envConfig = loadEnvConfig();
+    // Merge configurations (priority: env > file > defaults)
+    const config = {
+        ...exports.DEFAULTS,
+        ...fileConfig,
+        ...envConfig,
+    };
+    // Resolve all paths to absolute
+    const pathKeys = ['harnessRoot', 'worktreesDir', 'tasksDir', 'snapshotsDir', 'archiveDir', 'reportsDir', 'plansDir', 'specRoot'];
+    for (const key of pathKeys) {
+        const value = config[key];
+        if (typeof value === 'string') {
+            const absKey = `${key}Abs`;
+            config[absKey] = resolvePath(value, projectRoot);
+        }
+    }
+    // Add derived paths
+    config.harnessRootAbs = resolvePath(config.harnessRoot, projectRoot);
+    config.tasksDirAbs = resolvePath(config.tasksDir, config.harnessRootAbs);
+    config.snapshotsDirAbs = resolvePath(config.snapshotsDir, config.harnessRootAbs);
+    config.archiveDirAbs = resolvePath(config.archiveDir, config.harnessRootAbs);
+    config.reportsDirAbs = resolvePath(config.reportsDir, config.harnessRootAbs);
+    config.plansDirAbs = resolvePath(config.plansDir, config.harnessRootAbs);
+    config.worktreesDirAbs = resolvePath(config.worktreesDir, projectRoot);
+    config.specRootAbs = resolvePath(config.specRoot, projectRoot);
+    // Add metadata
+    config.projectRoot = projectRoot;
+    config.configPath = configPath || undefined;
+    config.configSources = {
+        defaults: exports.DEFAULTS,
+        file: fileConfig,
+        env: envConfig,
+    };
+    return config;
+}
+/**
+ * Get a specific config value
+ * @param key - Config key
+ * @param defaultValue - Default value if not found
+ * @param options - Options
+ * @returns Config value
+ */
+function getConfig(key, defaultValue, options = {}) {
+    const config = loadConfig(options);
+    const value = config[key] || config[`${key}Abs`] || defaultValue;
+    return value;
+}
+/**
+ * Ensure all harness directories exist
+ * @param config - Config object
+ */
+function ensureDirectories(config) {
+    const dirs = [
+        config.harnessRootAbs,
+        config.tasksDirAbs,
+        config.snapshotsDirAbs,
+        config.archiveDirAbs,
+        config.reportsDirAbs,
+        config.plansDirAbs,
+        config.worktreesDirAbs,
+    ];
+    for (const dir of dirs) {
+        if (dir) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}

package/dist/lib/constants.d.ts

@@ -0,0 +1,222 @@
+/**
+ * lib/constants.ts
+ * Shared constants and magic strings for task-flow
+ *
+ * Centralizes all magic strings, status values, phase names, and error codes
+ * to ensure consistency across the codebase.
+ */
+/**
+ * Phase names
+ */
+export declare const PHASE: {
+    readonly PLANNING: "planning";
+    readonly IMPLEMENTATION: "implementation";
+    readonly REVIEW: "review";
+    readonly MERGE: "merge";
+};
+export type Phase = typeof PHASE[keyof typeof PHASE];
+/**
+ * Status values
+ */
+export declare const STATUS: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly BLOCKED: "blocked";
+    readonly FAILED: "failed";
+    readonly SKIPPED: "skipped";
+    readonly ACTIVE: "active";
+};
+export type Status = typeof STATUS[keyof typeof STATUS];
+/**
+ * Review conclusions
+ */
+export declare const REVIEW_CONCLUSION: {
+    readonly PASS: "PASS";
+    readonly NEEDS_WORK: "NEEDS_WORK";
+    readonly FAIL: "FAIL";
+};
+export type ReviewConclusion = typeof REVIEW_CONCLUSION[keyof typeof REVIEW_CONCLUSION];
+/**
+ * Validation status values
+ */
+export declare const VALIDATION_STATUS: {
+    readonly PASS: "pass";
+    readonly PASSED: "passed";
+    readonly SUCCESS: "success";
+    readonly OK: "ok";
+    readonly TRUE: "true";
+    readonly FAIL: "fail";
+    readonly FAILED: "failed";
+};
+/**
+ * Validated status values (for passed validations)
+ */
+export declare const VALIDATED_STATUSES: readonly ["pass", "passed", "success", "ok", "true"];
+/**
+ * Merge strategy types
+ */
+export declare const MERGE_TYPE: {
+    readonly SQUASH: "squash";
+    readonly MERGE: "merge";
+    readonly REBASE: "rebase";
+};
+export type MergeType = typeof MERGE_TYPE[keyof typeof MERGE_TYPE];
+/**
+ * Default merge configuration
+ */
+export declare const DEFAULT_MERGE_CONFIG: {
+    readonly type: "squash";
+    readonly deleteBranch: true;
+    readonly deleteWorktree: true;
+};
+/**
+ * Allowed commands for CLI execution (security whitelist)
+ */
+export declare const ALLOWED_COMMANDS: readonly ["git", "node", "pnpm", "npm", "yarn", "tsc", "eslint", "prettier", "jest", "vitest", "mocha", "tsx", "ts-node"];
+export type AllowedCommand = typeof ALLOWED_COMMANDS[number];
+/**
+ * Check if a command is allowed
+ * @param cmd - Command to check
+ * @returns True if command is allowed
+ */
+export declare function isAllowedCommand(cmd: string): cmd is AllowedCommand;
+/**
+ * File patterns
+ */
+export declare const FILE_PATTERNS: {
+    readonly TASK_JSON: RegExp;
+    readonly SNAPSHOT_JSON: RegExp;
+    readonly REVIEW_MD: RegExp;
+    readonly PROPOSAL_MD: RegExp;
+    readonly DESIGN_MD: RegExp;
+    readonly TASKS_MD: RegExp;
+    readonly EXECUTION_JSON: RegExp;
+    readonly MANIFEST_JSON: RegExp;
+};
+/**
+ * Directory names
+ */
+export declare const DIR_NAMES: {
+    readonly HARNESS: ".harness";
+    readonly SPEC: "spec";
+    readonly CHANGES: "changes";
+    readonly TASKS: "tasks";
+    readonly SNAPSHOTS: "snapshots";
+    readonly REPORTS: "reports";
+    readonly ARCHIVE: "archive";
+    readonly WORKTREES: ".worktrees";
+    readonly SKILLS: "skills";
+};
+/**
+ * State file names
+ */
+export declare const STATE_FILES: {
+    readonly STATE: "state.json";
+    readonly CONFIG: ".harnessrc";
+    readonly HOOKS: "hooks.json";
+    readonly MCP: "mcp.json";
+    readonly SKILLS: "skills.json";
+};
+/**
+ * Hook names
+ */
+export declare const HOOK_NAMES: {
+    readonly PRE_DESIGN: "pre-design";
+    readonly POST_DESIGN: "post-design";
+    readonly PRE_TASKS: "pre-tasks";
+    readonly POST_TASKS: "post-tasks";
+    readonly PRE_WORKTREE: "pre-worktree";
+    readonly POST_WORKTREE: "post-worktree";
+    readonly PRE_SNAPSHOT: "pre-snapshot";
+    readonly POST_SNAPSHOT: "post-snapshot";
+    readonly PRE_REVIEW: "pre-review";
+    readonly POST_REVIEW: "post-review";
+    readonly PRE_MERGE: "pre-merge";
+    readonly POST_MERGE: "post-merge";
+};
+/**
+ * Gate validation names
+ */
+export declare const GATE_VALIDATIONS: {
+    readonly BUILD_PASSES: "build-passes";
+    readonly TESTS_PASS: "tests-pass";
+    readonly TYPECHECK_PASSES: "typecheck-passes";
+    readonly LINT_PASSES: "lint-passes";
+    readonly SECURITY_CHECK: "security-check";
+    readonly COVERAGE_GE_80: "coverage-ge-80";
+    readonly REVIEW_CONCLUSION: "review-conclusion";
+    readonly PLANNING_READY: "planning-ready";
+};
+/**
+ * Validation aliases (maps validation name to alternative names)
+ */
+export declare const VALIDATION_ALIASES: Record<string, string[]>;
+/**
+ * Agent types
+ */
+export declare const AGENT_TYPES: {
+    readonly CLAUDE_CODE: "claude-code";
+    readonly TRAE: "trae";
+    readonly QODER: "qoder";
+};
+export type AgentType = typeof AGENT_TYPES[keyof typeof AGENT_TYPES];
+/**
+ * Skill formats
+ */
+export declare const SKILL_FORMAT: {
+    readonly COPY_SKILL_MD: "copy-skill-md";
+    readonly COPY_DIRECTORY: "copy-directory";
+    readonly SYMLINK: "symlink";
+};
+export type SkillFormat = typeof SKILL_FORMAT[keyof typeof SKILL_FORMAT];
+/**
+ * Event types for archiving
+ */
+export declare const EVENT_TYPES: {
+    readonly TASK_STARTED: "task_started";
+    readonly PHASE_STARTED: "phase_started";
+    readonly PHASE_COMPLETED: "phase_completed";
+    readonly SNAPSHOT_CREATED: "snapshot_created";
+    readonly REVIEW_COMPLETED: "review_completed";
+    readonly TASK_MERGED: "task_merged";
+    readonly TASK_COMPLETED: "task_completed";
+    readonly GATE_BLOCKED: "gate_blocked";
+};
+export type EventType = typeof EVENT_TYPES[keyof typeof EVENT_TYPES];
+/**
+ * Error codes
+ */
+export declare const ERROR_CODES: {
+    readonly MISSING_CHANGE: "missing-change";
+    readonly INVALID_CHANGE: "invalid-change";
+    readonly MISSING_TASK_ID: "missing-task-id";
+    readonly INVALID_TASK_ID: "invalid-task-id";
+    readonly MISSING_TASK_FILE: "missing-task-file";
+    readonly MISSING_SPEC: "missing-spec";
+    readonly MISSING_METADATA: "missing-metadata";
+    readonly ALREADY_EXISTS: "already-exists";
+    readonly NOT_FOUND: "not-found";
+    readonly VALIDATION_FAILED: "validation-failed";
+    readonly GATE_BLOCKED: "gate-blocked";
+    readonly MERGE_FAILED: "merge-failed";
+    readonly WORKTREE_CONFLICT: "worktree-conflict";
+    readonly REVIEW_NOT_PASSED: "review-not-passed";
+    readonly MISSING_REVIEW: "missing-review";
+    readonly MISSING_WORKTREE: "missing-worktree";
+    readonly MISSING_BRANCH: "missing-branch";
+    readonly DIRTY_WORKTREE: "dirty-worktree";
+    readonly CANCELLED: "cancelled";
+    readonly SYNC_FAILED: "sync-failed";
+    readonly UNKNOWN_ERROR: "unknown-error";
+};
+export type ErrorCode = typeof ERROR_CODES[keyof typeof ERROR_CODES];
+/**
+ * Default values
+ */
+export declare const DEFAULTS: {
+    readonly TIMEOUT: 300000;
+    readonly FORCE_KILL_TIMEOUT: 5000;
+    readonly MAX_HISTORY_ENTRIES: 100;
+    readonly MAX_WORKTREES: 10;
+};