@bicorne/task-flow 0.1.0

package/dist/spec/openspec-to-task/index.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * spec/openspec-to-task/index.ts
+ * Sync Spec change to harness task definition
+ *
+ * Usage:
+ *   node sync-openspec-to-task.js --change <change-name> [options]
+ */
+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.syncSpecToTask = syncSpecToTask;
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../lib/config");
+const parsers_1 = require("./parsers");
+const builders_1 = require("./builders");
+/**
+ * Validate config has required properties for sync
+ */
+function validateConfigForSync(config) {
+    if (!config.projectRoot) {
+        return {
+            valid: false,
+            reason: 'missing-project-root',
+            message: 'Config missing projectRoot',
+        };
+    }
+    if (!config.specRootAbs) {
+        return {
+            valid: false,
+            reason: 'missing-spec-root',
+            message: 'Config missing specRootAbs',
+        };
+    }
+    if (!config.tasksDirAbs) {
+        return {
+            valid: false,
+            reason: 'missing-tasks-dir',
+            message: 'Config missing tasksDirAbs',
+        };
+    }
+    return { valid: true };
+}
+/**
+ * Sync Spec to task
+ */
+function syncSpecToTask(options = {}) {
+    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
+    const changeName = String(options.change || '').trim();
+    if (!changeName) {
+        return {
+            success: false,
+            reason: 'missing-change',
+            message: 'Missing required argument: --change <change-name>',
+        };
+    }
+    // Validate config before use
+    const configValidation = validateConfigForSync(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 proposalPath = path.resolve(changeDir, 'product-requirement.md');
+    const designPath = path.resolve(changeDir, 'design.md');
+    const tasksPath = path.resolve(changeDir, 'tasks.md');
+    if (!fs.existsSync(changeDir)) {
+        return {
+            success: false,
+            reason: 'missing-change-dir',
+            message: `Spec change not found: ${changeDir}`,
+        };
+    }
+    // Continue with sync only if change directory exists
+    const proposalContent = (0, parsers_1.readIfExists)(proposalPath);
+    const designContent = (0, parsers_1.readIfExists)(designPath);
+    const tasksContent = (0, parsers_1.readIfExists)(tasksPath);
+    const { manifestPath, manifest, executionPath } = (0, parsers_1.resolveStructuredConfig)(changeDir, changeName);
+    const syncParams = (0, builders_1.buildSyncParams)(options, config, changeName, changeDir, proposalContent, designContent, tasksContent, manifest, manifestPath, executionPath);
+    const taskOutputPath = path.resolve(projectRoot, String(options.output || path.relative(projectRoot, path.resolve(config.tasksDirAbs, `${syncParams.taskId}.json`))));
+    const taskJson = (0, builders_1.buildTaskJson)({
+        ...syncParams,
+        changeName,
+        manifestPath,
+        executionPath,
+        config,
+    });
+    if (options.dryRun) {
+        return {
+            success: true,
+            taskId: syncParams.taskId,
+            json: taskJson,
+            dryRun: true,
+        };
+    }
+    fs.mkdirSync(path.dirname(taskOutputPath), { recursive: true });
+    if (!options.force && fs.existsSync(taskOutputPath)) {
+        return {
+            success: false,
+            reason: 'file-exists',
+            message: 'Target task file already exists. Use --force to overwrite.',
+        };
+    }
+    fs.writeFileSync(taskOutputPath, taskJson, 'utf8');
+    return {
+        success: true,
+        taskId: syncParams.taskId,
+        taskPath: (0, parsers_1.ensurePosix)(path.relative(config.projectRoot, taskOutputPath)),
+    };
+}
+/**
+ * Main entry point
+ */
+function main() {
+    const args = (0, parsers_1.parseArgs)(process.argv);
+    const result = syncSpecToTask({
+        cwd: args.cwd,
+        change: args.change,
+        taskId: args['task-id'],
+        type: args.type,
+        priority: args.priority,
+        worktree: args.worktree,
+        output: args.output,
+        force: args.force === true,
+        dryRun: args['dry-run'] === true,
+    });
+    if (!result.success) {
+        console.error(`[SPEC-SYNC] ${result.message}`);
+        process.exit(1);
+    }
+    if (result.dryRun) {
+        const jsonOutput = result.json || '';
+        process.stdout.write(jsonOutput);
+        process.exit(0);
+    }
+    console.log(`[SPEC-SYNC] Generated task: ${result.taskPath}`);
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}
+exports.default = {
+    syncSpecToTask,
+};

package/dist/spec/openspec-to-task/parsers.d.ts

@@ -0,0 +1,65 @@
+/**
+ * spec/openspec-to-task/parsers.ts
+ * Parsing and extraction utilities for Spec to task sync
+ */
+import { ManifestJson } from './types';
+/**
+ * Parse CLI arguments
+ */
+export declare function parseArgs(argv: string[]): Record<string, string | boolean>;
+/**
+ * Ensure POSIX path
+ */
+export declare function ensurePosix(p: string | undefined): string;
+/**
+ * Sanitize task ID
+ */
+export declare function toTaskId(input: string | undefined): string;
+/**
+ * Generate worktree name
+ */
+export declare function toWorktreeName(type: string, taskId: string): string;
+/**
+ * Read file if exists
+ */
+export declare function readIfExists(filePath: string): string;
+/**
+ * Read JSON if exists
+ */
+export declare function readJsonIfExists<T>(filePath: string): T | null;
+/**
+ * Deduplicate array
+ */
+export declare function uniqueArray(items: (string | undefined)[]): string[];
+/**
+ * Normalize boolean
+ */
+export declare function normalizeBoolean(value: unknown, fallback: boolean): boolean;
+/**
+ * Extract title from proposal
+ */
+export declare function extractTitle(changeName: string, proposalContent: string): string;
+/**
+ * Extract checklist items from tasks.md
+ */
+export declare function extractChecklistItems(tasksContent: string): string[];
+/**
+ * Extract file candidates from text
+ */
+export declare function extractFileCandidates(texts: (string | null)[]): string[];
+/**
+ * Infer implementation validations
+ */
+export declare function inferImplementationValidations(checklistItems: string[]): string[];
+/**
+ * Infer review validations
+ */
+export declare function inferReviewValidations(checklistItems: string[]): string[];
+/**
+ * Resolve structured config from change directory
+ */
+export declare function resolveStructuredConfig(changeDir: string, changeName: string): {
+    manifestPath: string;
+    manifest: ManifestJson;
+    executionPath: string;
+};

package/dist/spec/openspec-to-task/parsers.js

@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * spec/openspec-to-task/parsers.ts
+ * Parsing and extraction utilities for Spec to task sync
+ */
+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.parseArgs = parseArgs;
+exports.ensurePosix = ensurePosix;
+exports.toTaskId = toTaskId;
+exports.toWorktreeName = toWorktreeName;
+exports.readIfExists = readIfExists;
+exports.readJsonIfExists = readJsonIfExists;
+exports.uniqueArray = uniqueArray;
+exports.normalizeBoolean = normalizeBoolean;
+exports.extractTitle = extractTitle;
+exports.extractChecklistItems = extractChecklistItems;
+exports.extractFileCandidates = extractFileCandidates;
+exports.inferImplementationValidations = inferImplementationValidations;
+exports.inferReviewValidations = inferReviewValidations;
+exports.resolveStructuredConfig = resolveStructuredConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse CLI arguments
+ */
+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;
+}
+/**
+ * Ensure POSIX path
+ */
+function ensurePosix(p) {
+    return String(p || '').replace(/\\/g, '/');
+}
+/**
+ * Sanitize task ID
+ */
+function toTaskId(input) {
+    return String(input || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9-_]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+/**
+ * Generate worktree name
+ */
+function toWorktreeName(type, taskId) {
+    return `harness-${type}-${taskId}`;
+}
+/**
+ * Read file if exists
+ */
+function readIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return '';
+    }
+    return fs.readFileSync(filePath, 'utf8');
+}
+/**
+ * Read JSON if exists
+ */
+function readJsonIfExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON: ${ensurePosix(filePath)} (${error instanceof Error ? error.message : 'Unknown error'})`, { cause: error });
+    }
+}
+/**
+ * Deduplicate array
+ */
+function uniqueArray(items) {
+    return [...new Set((Array.isArray(items) ? items : []).filter(Boolean).map((item) => ensurePosix(String(item).trim())))];
+}
+/**
+ * Normalize boolean
+ */
+function normalizeBoolean(value, fallback) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        if (value === 'true') {
+            return true;
+        }
+        if (value === 'false') {
+            return false;
+        }
+    }
+    return fallback;
+}
+/**
+ * Extract title from proposal
+ */
+function extractTitle(changeName, proposalContent) {
+    const lines = proposalContent.split(/\r?\n/);
+    const heading = lines.find((line) => /^#\s+/.test(line));
+    if (!heading) {
+        return `Spec 变更：${changeName}`;
+    }
+    return heading.replace(/^#\s+/, '').trim();
+}
+/**
+ * Extract checklist items from tasks.md
+ */
+function extractChecklistItems(tasksContent) {
+    const lines = tasksContent.split(/\r?\n/);
+    const items = [];
+    for (const line of lines) {
+        const match = line.match(/^\s*[-*]\s+\[(?: |x|X)\]\s+(.+)\s*$/);
+        if (match) {
+            items.push(match?.[1]?.trim() || '');
+        }
+    }
+    return items;
+}
+/**
+ * Extract file candidates from text
+ */
+function extractFileCandidates(texts) {
+    const merged = texts.filter(Boolean).join('\n');
+    const regex = /(?:^|[\s(])((?:server|web|docs|scripts|spec|\.harness|packages)\/[^\s):`'"]+\.[a-zA-Z0-9]+)(?=$|[\s),`'"])/gm;
+    const result = [];
+    let match = regex.exec(merged);
+    while (match) {
+        const file = ensurePosix(match?.[1]?.trim() || '');
+        if (file && !result.includes(file)) {
+            result.push(file);
+        }
+        match = regex.exec(merged);
+    }
+    return result;
+}
+/**
+ * Infer implementation validations
+ */
+function inferImplementationValidations(checklistItems) {
+    const source = checklistItems.join('\n').toLowerCase();
+    const values = [];
+    if (/build|构建/.test(source)) {
+        values.push('build-passes');
+    }
+    if (/test|测试|回归/.test(source)) {
+        values.push('tests-pass');
+    }
+    if (/type|类型/.test(source)) {
+        values.push('typecheck-passes');
+    }
+    if (/lint|格式|规范/.test(source)) {
+        values.push('lint-passes');
+    }
+    if (values.length === 0) {
+        values.push('build-passes', 'tests-pass', 'typecheck-passes', 'lint-passes');
+    }
+    return values;
+}
+/**
+ * Infer review validations
+ */
+function inferReviewValidations(checklistItems) {
+    const source = checklistItems.join('\n').toLowerCase();
+    const values = ['security-check', 'review-conclusion'];
+    if (/cover|覆盖率/.test(source)) {
+        values.splice(1, 0, 'coverage-ge-80');
+    }
+    return values;
+}
+/**
+ * Resolve structured config from change directory
+ */
+function resolveStructuredConfig(changeDir, changeName) {
+    const manifestPath = path.resolve(changeDir, 'manifest.json');
+    const manifest = readJsonIfExists(manifestPath) || {};
+    return {
+        manifestPath: ensurePosix(path.relative(process.cwd(), manifestPath)),
+        manifest,
+        executionPath: ensurePosix(manifest.execution || `spec/changes/${changeName}/execution.json`),
+    };
+}

package/dist/spec/openspec-to-task/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * spec/openspec-to-task/types.ts
+ * Type definitions for Spec to task sync
+ */
+/**
+ * Sync options
+ */
+export interface SyncOptions {
+    cwd?: string;
+    change?: string;
+    taskId?: string;
+    type?: string;
+    priority?: string;
+    worktree?: string;
+    output?: string;
+    force?: boolean;
+    dryRun?: boolean;
+}
+/**
+ * Sync result
+ */
+export interface SyncResult {
+    success: boolean;
+    reason?: string;
+    message?: string;
+    taskId?: string;
+    taskPath?: string;
+    json?: string;
+    dryRun?: boolean;
+}
+/**
+ * Manifest JSON structure
+ */
+export interface ManifestJson {
+    taskId?: string;
+    type?: string;
+    priority?: string;
+    title?: string;
+    files?: string[];
+    worktree?: string;
+    implementationValidation?: string[];
+    reviewValidation?: string[];
+    mergeStrategy?: {
+        type?: string;
+        deleteBranch?: boolean;
+        deleteWorktree?: boolean;
+    };
+    execution?: string;
+}

package/dist/spec/openspec-to-task/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * spec/openspec-to-task/types.ts
+ * Type definitions for Spec to task sync
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/spec/sync-openspec-to-task.d.ts

@@ -0,0 +1,7 @@
+/**
+ * sync-openspec-to-task.ts
+ * Backward-compatible re-export from openspec-to-task/ module
+ * @deprecated Import from '../spec/openspec-to-task/index' directly
+ */
+export { syncSpecToTask, main, default } from './openspec-to-task/index';
+export { SyncOptions, SyncResult, ManifestJson } from './openspec-to-task/types';

package/dist/spec/sync-openspec-to-task.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * sync-openspec-to-task.ts
+ * Backward-compatible re-export from openspec-to-task/ module
+ * @deprecated Import from '../spec/openspec-to-task/index' directly
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.main = exports.syncSpecToTask = void 0;
+var index_1 = require("./openspec-to-task/index");
+Object.defineProperty(exports, "syncSpecToTask", { enumerable: true, get: function () { return index_1.syncSpecToTask; } });
+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; } });
+// Allow direct execution when invoked via spawnSync
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { main: runMain } = require('./openspec-to-task/index');
+if (require.main === module) {
+    runMain();
+}

package/dist/spec/sync-task-to-openspec.d.ts

@@ -0,0 +1,27 @@
+/**
+ * sync-task-to-openspec.ts
+ * Sync task execution status back to Spec
+ */
+export interface SyncOptions {
+    cwd?: string;
+    taskId?: string;
+}
+export interface SyncResult {
+    skipped: boolean;
+    reason?: string;
+    taskId?: string;
+    change?: string;
+    executionPath?: string;
+}
+/**
+ * Sync task to Spec
+ */
+export declare function syncTaskToSpec(options?: SyncOptions): SyncResult;
+/**
+ * Main entry point
+ */
+export declare function main(): void;
+declare const _default: {
+    syncTaskToSpec: typeof syncTaskToSpec;
+};
+export default _default;