@niujiajie/freespec 0.0.0-stage → 1.15.0

package/dist/core/openspec-root.js

@@ -0,0 +1,196 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { DEFAULT_SCHEMA as DEFAULT_OPENSPEC_SCHEMA } from './change-layout.js';
+import { serializeConfig } from './config-prompts.js';
+import { makeStoreDiagnostic, } from './store/errors.js';
+export const OPENSPEC_ROOT_DIR = 'freespec';
+export const OPENSPEC_CONFIG_YAML = 'freespec/config.yaml';
+export const OPENSPEC_CONFIG_YML = 'freespec/config.yml';
+export const OPENSPEC_SPECS_DIR = 'freespec/specs';
+/** Change folders sit directly under `freespec/`, named `<名称>变更`. */
+export const OPENSPEC_CHANGES_DIR = 'freespec';
+export { DEFAULT_OPENSPEC_SCHEMA };
+export const DIRECTORY_ANCHOR_FILE_NAME = '.gitkeep';
+// Git cannot track empty directories, so setup anchors otherwise-empty
+// conventional store directories for teammates who clone the repo later.
+export const ANCHORED_OPENSPEC_DIRS = [];
+async function pathKind(targetPath) {
+    try {
+        const stat = await fs.stat(targetPath);
+        if (stat.isDirectory())
+            return 'directory';
+        if (stat.isFile())
+            return 'file';
+        return 'other';
+    }
+    catch (error) {
+        if (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'ENOENT') {
+            return 'missing';
+        }
+        throw error;
+    }
+}
+function relativeArtifact(relativePath, kind) {
+    const normalized = FileSystemUtils.toPosixPath(relativePath);
+    return kind === 'directory' ? `${normalized}/` : normalized;
+}
+function unresolvedInspection() {
+    return {
+        present: null,
+        config: { present: null },
+        specs: { present: null },
+        changes: { present: null },
+        archive: { present: null },
+        healthy: false,
+        diagnostics: [],
+    };
+}
+function missingDirectoryDiagnostic(code, message, target) {
+    return makeStoreDiagnostic('error', code, message, { target });
+}
+async function inspectOptionalPlanningDirectory(inspection, storeRoot, key, relativePath, notDirectoryCode, target) {
+    const kind = await pathKind(path.join(storeRoot, relativePath));
+    inspection[key] = { present: kind === 'directory' };
+    if (kind === 'directory' || kind === 'missing')
+        return kind;
+    inspection.diagnostics.push(missingDirectoryDiagnostic(notDirectoryCode, `${relativePath}/ exists but is not a directory.`, target));
+    return kind;
+}
+export async function inspectFreeSpecRoot(storeRoot) {
+    const rootKind = await pathKind(storeRoot);
+    const inspection = unresolvedInspection();
+    if (rootKind === 'missing') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_store_root_missing', 'Store root does not exist.', 'store.root'));
+        return inspection;
+    }
+    if (rootKind !== 'directory') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_store_root_not_directory', 'Store root is not a directory.', 'store.root'));
+        return inspection;
+    }
+    const freespecPath = path.join(storeRoot, OPENSPEC_ROOT_DIR);
+    const freespecKind = await pathKind(freespecPath);
+    inspection.present = freespecKind === 'directory';
+    if (freespecKind === 'missing') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_root_missing', 'Missing freespec/ directory.', 'freespec.root'));
+        return inspection;
+    }
+    if (freespecKind !== 'directory') {
+        inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_root_not_directory', 'freespec/ exists but is not a directory.', 'freespec.root'));
+        return inspection;
+    }
+    const configYamlKind = await pathKind(path.join(storeRoot, OPENSPEC_CONFIG_YAML));
+    const configYmlKind = await pathKind(path.join(storeRoot, OPENSPEC_CONFIG_YML));
+    if (configYamlKind === 'file') {
+        inspection.config = { present: true, path: OPENSPEC_CONFIG_YAML };
+    }
+    else if (configYmlKind === 'file') {
+        inspection.config = { present: true, path: OPENSPEC_CONFIG_YML };
+    }
+    else {
+        inspection.config = { present: false };
+        if (configYamlKind !== 'missing' || configYmlKind !== 'missing') {
+            inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_config_not_file', 'FreeSpec config path exists but is not a file.', 'freespec.config'));
+        }
+        else {
+            inspection.diagnostics.push(missingDirectoryDiagnostic('freespec_config_missing', 'Missing freespec/config.yaml or freespec/config.yml.', 'freespec.config'));
+        }
+    }
+    await inspectOptionalPlanningDirectory(inspection, storeRoot, 'specs', OPENSPEC_SPECS_DIR, 'freespec_specs_not_directory', 'freespec.specs');
+    await inspectOptionalPlanningDirectory(inspection, storeRoot, 'changes', OPENSPEC_CHANGES_DIR, 'freespec_changes_not_directory', 'freespec.changes');
+    inspection.archive = { present: false };
+    inspection.healthy =
+        inspection.present === true &&
+            inspection.config.present === true &&
+            inspection.diagnostics.length === 0;
+    return inspection;
+}
+async function ensureDirectory(storeRoot, relativePath, ledger) {
+    const absolutePath = path.join(storeRoot, relativePath);
+    const kind = await pathKind(absolutePath);
+    if (kind === 'directory')
+        return;
+    if (kind !== 'missing') {
+        throw new Error(`${relativePath}/ exists but is not a directory.`);
+    }
+    await fs.mkdir(absolutePath, { recursive: true });
+    ledger.push({
+        relativePath: relativeArtifact(relativePath, 'directory'),
+        absolutePath,
+        kind: 'directory',
+    });
+}
+async function ensureDefaultConfig(storeRoot, ledger) {
+    const configYamlPath = path.join(storeRoot, OPENSPEC_CONFIG_YAML);
+    const configYmlPath = path.join(storeRoot, OPENSPEC_CONFIG_YML);
+    const yamlKind = await pathKind(configYamlPath);
+    const ymlKind = await pathKind(configYmlPath);
+    if (yamlKind === 'file' || ymlKind === 'file')
+        return;
+    if (yamlKind !== 'missing' || ymlKind !== 'missing') {
+        throw new Error('FreeSpec config path exists but is not a file.');
+    }
+    await FileSystemUtils.writeFile(configYamlPath, serializeConfig({ schema: DEFAULT_OPENSPEC_SCHEMA }));
+    ledger.push({
+        relativePath: relativeArtifact(OPENSPEC_CONFIG_YAML, 'file'),
+        absolutePath: configYamlPath,
+        kind: 'file',
+    });
+}
+export async function ensureDirectoryAnchor(storeRoot, relativeDir, ledger = []) {
+    const directory = path.join(storeRoot, relativeDir);
+    if ((await fs.readdir(directory)).length > 0)
+        return;
+    const relativePath = `${relativeDir}/${DIRECTORY_ANCHOR_FILE_NAME}`;
+    const absolutePath = path.join(directory, DIRECTORY_ANCHOR_FILE_NAME);
+    try {
+        // A file or symlink may appear after readdir. Never replace or follow it.
+        await fs.writeFile(absolutePath, '', { encoding: 'utf-8', flag: 'wx' });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return;
+        throw error;
+    }
+    ledger.push({
+        relativePath: relativeArtifact(relativePath, 'file'),
+        absolutePath,
+        kind: 'file',
+    });
+}
+export async function ensureFreeSpecRoot(storeRoot, options = {}) {
+    const ledger = [];
+    const rootKind = await pathKind(storeRoot);
+    if (rootKind === 'missing') {
+        await fs.mkdir(storeRoot, { recursive: true });
+    }
+    else if (rootKind !== 'directory') {
+        throw new Error('Store root is not a directory.');
+    }
+    await ensureDirectory(storeRoot, OPENSPEC_ROOT_DIR, ledger);
+    await ensureDefaultConfig(storeRoot, ledger);
+    if (options.anchorEmptyDirectories) {
+        for (const relativeDir of ANCHORED_OPENSPEC_DIRS) {
+            await ensureDirectoryAnchor(storeRoot, relativeDir, ledger);
+        }
+    }
+    return {
+        inspection: await inspectFreeSpecRoot(storeRoot),
+        createdArtifacts: ledger.map((entry) => entry.relativePath),
+        createdPaths: ledger,
+    };
+}
+export async function rollbackCreatedPaths(entries) {
+    for (const entry of [...entries].reverse()) {
+        if (entry.kind === 'file') {
+            await fs.rm(entry.absolutePath, { force: true }).catch(() => undefined);
+        }
+        else {
+            await fs.rmdir(entry.absolutePath).catch(() => undefined);
+        }
+    }
+}
+//# sourceMappingURL=openspec-root.js.map

package/dist/core/planning-home.d.ts

@@ -0,0 +1,16 @@
+export type PlanningHomeKind = 'repo';
+export interface PlanningHome {
+    kind: PlanningHomeKind;
+    root: string;
+    changesDir: string;
+    defaultSchema: string;
+}
+export interface ResolvePlanningHomeOptions {
+    startPath?: string;
+    allowImplicitRepoRoot?: boolean;
+}
+export declare function findRepoPlanningRootSync(startPath?: string): string | null;
+export declare function resolveCurrentPlanningHomeSync(options?: ResolvePlanningHomeOptions): PlanningHome;
+export declare function getChangeDir(planningHome: PlanningHome, changeName: string): string;
+export declare function formatChangeLocation(planningHome: PlanningHome, changeName: string): string;
+//# sourceMappingURL=planning-home.d.ts.map

package/dist/core/planning-home.js

@@ -0,0 +1,67 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { changeParentDir, DEFAULT_SCHEMA } from './change-layout.js';
+function pathExistsAsDirectory(candidatePath) {
+    try {
+        return fs.statSync(candidatePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function getSearchStartDirectory(startPath) {
+    const resolved = path.resolve(startPath);
+    try {
+        const stats = fs.statSync(resolved);
+        const searchStart = stats.isDirectory() ? resolved : path.dirname(resolved);
+        return FileSystemUtils.canonicalizeExistingPath(searchStart);
+    }
+    catch {
+        return resolved;
+    }
+}
+function findNearestAncestor(startPath, predicate) {
+    let currentDir = getSearchStartDirectory(startPath);
+    while (true) {
+        if (predicate(currentDir)) {
+            return FileSystemUtils.canonicalizeExistingPath(currentDir);
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export function findRepoPlanningRootSync(startPath = process.cwd()) {
+    return findNearestAncestor(startPath, (dirPath) => pathExistsAsDirectory(path.join(dirPath, 'freespec')));
+}
+function repoPlanningHome(repoRoot) {
+    return {
+        kind: 'repo',
+        root: repoRoot,
+        changesDir: changeParentDir(repoRoot),
+        defaultSchema: DEFAULT_SCHEMA,
+    };
+}
+export function resolveCurrentPlanningHomeSync(options = {}) {
+    const startPath = options.startPath ?? process.cwd();
+    const searchStart = getSearchStartDirectory(startPath);
+    const repoRoot = findRepoPlanningRootSync(searchStart);
+    if (repoRoot) {
+        return repoPlanningHome(repoRoot);
+    }
+    if (options.allowImplicitRepoRoot === false) {
+        throw new Error('No FreeSpec planning home found from the current directory.');
+    }
+    return repoPlanningHome(FileSystemUtils.canonicalizeExistingPath(searchStart));
+}
+export function getChangeDir(planningHome, changeName) {
+    return FileSystemUtils.joinPath(planningHome.changesDir, changeName);
+}
+export function formatChangeLocation(planningHome, changeName) {
+    // Repo homes always nest changesDir under the root.
+    return path.relative(planningHome.root, getChangeDir(planningHome, changeName));
+}
+//# sourceMappingURL=planning-home.js.map

package/dist/core/profile-sync-drift.d.ts

@@ -0,0 +1,31 @@
+import type { Delivery } from './global-config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import { type FileView } from './file-view.js';
+type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export declare const WORKFLOW_TO_SKILL_DIR: Record<WorkflowId, string>;
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export declare function getConfiguredToolsForProfileSync(projectPath: string, view?: FileView): string[];
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export declare function hasToolProfileOrDeliveryDrift(projectPath: string, toolId: string, desiredWorkflows: readonly string[], delivery: Delivery, view?: FileView): boolean;
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export declare function getToolsNeedingProfileSync(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery, configuredTools?: readonly string[], view?: FileView): string[];
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export declare function hasProjectConfigDrift(projectPath: string, desiredWorkflows: readonly string[], delivery: Delivery): boolean;
+export {};
+//# sourceMappingURL=profile-sync-drift.d.ts.map

package/dist/core/profile-sync-drift.js

@@ -0,0 +1,201 @@
+import path from 'path';
+import * as fs from 'fs';
+import { AI_TOOLS } from './config.js';
+import { ALL_WORKFLOWS } from './profiles.js';
+import { CommandAdapterRegistry } from './command-generation/index.js';
+import { getConfiguredTools } from './shared/index.js';
+import { shouldGenerateCommandsForTool, shouldGenerateSkillsForTool, shouldReconcileCommandFilesForTool, shouldRemoveSkillsForTool, } from './command-surface.js';
+import { readSharedSkillTarget } from './shared-skill-target.js';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { DISK_VIEW } from './file-view.js';
+import { isLegacyCodexSkillEquivalentToCurrent } from './shared/skill-content-equivalence.js';
+import { hasGlobalSkillTarget, resolveToolSkillsDir, toolSupportsSkills, } from './shared/skill-paths.js';
+/**
+ * Maps workflow IDs to their skill directory names.
+ */
+export const WORKFLOW_TO_SKILL_DIR = {
+    '新建': 'freespec-新建',
+    '深思': 'freespec-深思',
+    '需求': 'freespec-需求',
+    '设计': 'freespec-设计',
+    '任务': 'freespec-任务',
+    '审文档': 'freespec-审文档',
+    '用例': 'freespec-用例',
+    '验收': 'freespec-验收',
+    '写Java': 'freespec-写Java',
+    '审Java': 'freespec-审Java',
+};
+function toKnownWorkflows(workflows) {
+    return workflows.filter((workflow) => ALL_WORKFLOWS.includes(workflow));
+}
+/**
+ * Returns tools that are configured via either skills or commands.
+ */
+export function getConfiguredToolsForProfileSync(projectPath, view = DISK_VIEW) {
+    return getConfiguredTools(projectPath, view);
+}
+/**
+ * Detects if a single tool has profile/delivery drift against the desired state.
+ *
+ * This function covers:
+ * - required artifacts missing for selected workflows
+ * - artifacts that should not exist for the selected delivery mode
+ * - artifacts for workflows that were deselected from the current profile
+ */
+export function hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery, view = DISK_VIEW) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool || !toolSupportsSkills(tool))
+        return false;
+    const knownDesiredWorkflows = toKnownWorkflows(desiredWorkflows);
+    const desiredWorkflowSet = new Set(knownDesiredWorkflows);
+    const skillsDir = resolveToolSkillsDir(projectPath, tool);
+    const adapter = CommandAdapterRegistry.get(toolId);
+    const shouldGenerateSkills = shouldGenerateSkillsForTool(toolId, delivery);
+    const shouldGenerateCommands = shouldGenerateCommandsForTool(toolId, delivery);
+    const sharedTarget = tool.skillsDir
+        ? readSharedSkillTarget(projectPath, tool.skillsDir, view)
+        : undefined;
+    for (const root of tool.legacySkillsDirs ?? []) {
+        for (const workflow of knownDesiredWorkflows) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const legacySkill = path.join(projectPath, root, 'skills', dirName, 'SKILL.md');
+            if (!view.exists(legacySkill))
+                continue;
+            const currentSkill = path.join(skillsDir, dirName, 'SKILL.md');
+            if (!view.exists(currentSkill) || sharedTarget !== toolId) {
+                return true;
+            }
+            try {
+                if (FileSystemUtils.canonicalizeExistingPath(legacySkill) ===
+                    FileSystemUtils.canonicalizeExistingPath(currentSkill)) {
+                    continue;
+                }
+                // Equivalent generated copies are actionable: migration can safely
+                // remove the redundant legacy file even when version, line endings,
+                // or supported invocation syntax changed. Materially divergent copies
+                // stay in place without forcing an update on every run.
+                if (isLegacyCodexSkillEquivalentToCurrent(view.read(legacySkill), view.read(currentSkill))) {
+                    return true;
+                }
+            }
+            catch {
+                return true;
+            }
+        }
+    }
+    if (shouldGenerateSkills) {
+        for (const workflow of knownDesiredWorkflows) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (!view.exists(skillFile)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (view.exists(skillDir)) {
+                return true;
+            }
+        }
+    }
+    else if (shouldRemoveSkillsForTool(toolId, delivery) && !hasGlobalSkillTarget(tool)) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillDir = path.join(skillsDir, dirName);
+            if (view.exists(skillDir)) {
+                return true;
+            }
+        }
+    }
+    if (shouldGenerateCommands && adapter) {
+        for (const workflow of knownDesiredWorkflows) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (!view.exists(fullPath)) {
+                return true;
+            }
+        }
+        // Deselecting workflows in a profile should trigger sync.
+        for (const workflow of ALL_WORKFLOWS) {
+            if (desiredWorkflowSet.has(workflow))
+                continue;
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (view.exists(fullPath)) {
+                return true;
+            }
+        }
+    }
+    else if (shouldReconcileCommandFilesForTool(toolId, delivery) && adapter) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const cmdPath = adapter.getFilePath(workflow);
+            const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+            if (view.exists(fullPath)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Returns configured tools that currently need a profile/delivery sync.
+ */
+export function getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools, view = DISK_VIEW) {
+    const tools = configuredTools
+        ? [...new Set(configuredTools)]
+        : getConfiguredToolsForProfileSync(projectPath, view);
+    return tools.filter((toolId) => hasToolProfileOrDeliveryDrift(projectPath, toolId, desiredWorkflows, delivery, view));
+}
+function getInstalledWorkflowsForTool(projectPath, toolId, options) {
+    const tool = AI_TOOLS.find((t) => t.value === toolId);
+    if (!tool || !toolSupportsSkills(tool))
+        return [];
+    const installed = new Set();
+    const skillsDir = resolveToolSkillsDir(projectPath, tool);
+    if (options.includeSkills) {
+        for (const workflow of ALL_WORKFLOWS) {
+            const dirName = WORKFLOW_TO_SKILL_DIR[workflow];
+            const skillFile = path.join(skillsDir, dirName, 'SKILL.md');
+            if (fs.existsSync(skillFile)) {
+                installed.add(workflow);
+            }
+        }
+    }
+    if (options.includeCommands) {
+        const adapter = CommandAdapterRegistry.get(toolId);
+        if (adapter) {
+            for (const workflow of ALL_WORKFLOWS) {
+                const cmdPath = adapter.getFilePath(workflow);
+                const fullPath = path.isAbsolute(cmdPath) ? cmdPath : path.join(projectPath, cmdPath);
+                if (fs.existsSync(fullPath)) {
+                    installed.add(workflow);
+                }
+            }
+        }
+    }
+    return [...installed];
+}
+/**
+ * Detects whether the current project has any profile/delivery drift.
+ */
+export function hasProjectConfigDrift(projectPath, desiredWorkflows, delivery) {
+    const configuredTools = getConfiguredToolsForProfileSync(projectPath);
+    if (getToolsNeedingProfileSync(projectPath, desiredWorkflows, delivery, configuredTools).length > 0) {
+        return true;
+    }
+    const desiredSet = new Set(toKnownWorkflows(desiredWorkflows));
+    for (const toolId of configuredTools) {
+        const includeSkills = shouldGenerateSkillsForTool(toolId, delivery);
+        const includeCommands = shouldGenerateCommandsForTool(toolId, delivery);
+        const installed = getInstalledWorkflowsForTool(projectPath, toolId, { includeSkills, includeCommands });
+        if (installed.some((workflow) => !desiredSet.has(workflow))) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=profile-sync-drift.js.map

package/dist/core/profiles.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Profiles control which workflows are installed.
+ * Delivery (in global config) controls how they are installed.
+ */
+import type { Profile } from './global-config.js';
+/** Workflows installed by the core profile, and the full set this build ships. */
+export declare const CORE_WORKFLOWS: readonly ["新建", "深思", "需求", "设计", "任务", "审文档", "用例", "验收", "写Java", "审Java"];
+export declare const ALL_WORKFLOWS: readonly ["新建", "深思", "需求", "设计", "任务", "审文档", "用例", "验收", "写Java", "审Java"];
+export type WorkflowId = (typeof ALL_WORKFLOWS)[number];
+export type CoreWorkflowId = (typeof CORE_WORKFLOWS)[number];
+/**
+ * Resolves which workflows should be active.
+ *
+ * - 'core' returns the full set.
+ * - 'custom' returns the requested ids that exist in that set.
+ *   Unknown ids are dropped. An empty result stays empty.
+ */
+export declare function getProfileWorkflows(profile: Profile, customWorkflows?: string[]): readonly string[];
+//# sourceMappingURL=profiles.d.ts.map

package/dist/core/profiles.js

@@ -0,0 +1,33 @@
+/**
+ * Profiles control which workflows are installed.
+ * Delivery (in global config) controls how they are installed.
+ */
+/** Workflows installed by the core profile, and the full set this build ships. */
+export const CORE_WORKFLOWS = [
+    '新建',
+    '深思',
+    '需求',
+    '设计',
+    '任务',
+    '审文档',
+    '用例',
+    '验收',
+    '写Java',
+    '审Java',
+];
+export const ALL_WORKFLOWS = CORE_WORKFLOWS;
+/**
+ * Resolves which workflows should be active.
+ *
+ * - 'core' returns the full set.
+ * - 'custom' returns the requested ids that exist in that set.
+ *   Unknown ids are dropped. An empty result stays empty.
+ */
+export function getProfileWorkflows(profile, customWorkflows) {
+    if (profile === 'custom') {
+        const known = new Set(ALL_WORKFLOWS);
+        return [...new Set((customWorkflows ?? []).filter((workflow) => known.has(workflow)))];
+    }
+    return CORE_WORKFLOWS;
+}
+//# sourceMappingURL=profiles.js.map