@clawplays/ospec-cli 0.1.1

package/dist/services/IndexBuilder.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexBuilder = exports.IndexBuilder = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../core/constants");
+const SKIP_DIRS = new Set(['node_modules', 'dist', '.git', 'changes', 'for-ai']);
+class IndexBuilder {
+    constructor(skillParser) {
+        this.skillParser = skillParser;
+    }
+    async build(rootDir) {
+        const modules = {};
+        const tagIndex = {};
+        let totalFiles = 0;
+        let totalSections = 0;
+        const visit = async (currentDir) => {
+            const entries = (await fs_extra_1.default.readdir(currentDir, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name));
+            for (const entry of entries) {
+                const fullPath = path_1.default.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name)) {
+                        await visit(fullPath);
+                    }
+                    continue;
+                }
+                if (entry.name !== constants_1.FILE_NAMES.SKILL_MD) {
+                    continue;
+                }
+                totalFiles++;
+                const relativePath = path_1.default.relative(rootDir, fullPath).replace(/\\/g, '/');
+                const content = await fs_extra_1.default.readFile(fullPath, 'utf-8');
+                const parsed = this.skillParser.parseSkillFile(content);
+                const moduleName = parsed.frontmatter.name || relativePath;
+                const title = parsed.frontmatter.title || parsed.frontmatter.name || relativePath;
+                const tags = parsed.frontmatter.tags || [];
+                const sections = parsed.sections;
+                totalSections += Object.keys(sections).length;
+                modules[moduleName] = {
+                    file: relativePath,
+                    title,
+                    tags,
+                    sections,
+                };
+                for (const tag of tags) {
+                    if (!tagIndex[tag]) {
+                        tagIndex[tag] = [];
+                    }
+                    tagIndex[tag].push(moduleName);
+                }
+            }
+        };
+        if (await fs_extra_1.default.pathExists(rootDir)) {
+            await visit(rootDir);
+        }
+        const activeChangesDir = path_1.default.join(rootDir, 'changes', 'active');
+        const activeChanges = (await fs_extra_1.default.pathExists(activeChangesDir))
+            ? (await fs_extra_1.default.readdir(activeChangesDir)).sort((left, right) => left.localeCompare(right))
+            : [];
+        for (const tag of Object.keys(tagIndex)) {
+            tagIndex[tag] = tagIndex[tag].sort((left, right) => left.localeCompare(right));
+        }
+        return {
+            version: '1.0',
+            generated: new Date().toISOString(),
+            git_commit: null,
+            active_changes: activeChanges,
+            stats: {
+                totalFiles,
+                totalModules: Object.keys(modules).length,
+                totalSections,
+            },
+            modules,
+            tagIndex,
+        };
+    }
+    async write(rootDir) {
+        const indexPath = path_1.default.join(rootDir, constants_1.FILE_NAMES.SKILL_INDEX);
+        const previous = (await fs_extra_1.default.pathExists(indexPath))
+            ? (await fs_extra_1.default.readJson(indexPath))
+            : null;
+        const index = await this.build(rootDir);
+        const previousComparable = previous ? this.stripVolatileFields(previous) : null;
+        const nextComparable = this.stripVolatileFields(index);
+        if (previous && JSON.stringify(previousComparable) === JSON.stringify(nextComparable)) {
+            return previous;
+        }
+        const output = {
+            ...index,
+            generated: new Date().toISOString(),
+        };
+        await fs_extra_1.default.writeFile(indexPath, JSON.stringify(output, null, 2), 'utf-8');
+        return output;
+    }
+    async createEmpty(rootDir) {
+        const indexPath = path_1.default.join(rootDir, constants_1.FILE_NAMES.SKILL_INDEX);
+        const previous = (await fs_extra_1.default.pathExists(indexPath))
+            ? (await fs_extra_1.default.readJson(indexPath))
+            : null;
+        const index = {
+            version: '1.0',
+            generated: new Date().toISOString(),
+            git_commit: null,
+            active_changes: [],
+            stats: {
+                totalFiles: 0,
+                totalModules: 0,
+                totalSections: 0,
+            },
+            modules: {},
+            tagIndex: {},
+        };
+        if (previous && JSON.stringify(this.stripVolatileFields(previous)) === JSON.stringify(this.stripVolatileFields(index))) {
+            return previous;
+        }
+        await fs_extra_1.default.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8');
+        return index;
+    }
+    stripVolatileFields(index) {
+        const { generated: _generated, ...stable } = index;
+        return stable;
+    }
+}
+exports.IndexBuilder = IndexBuilder;
+const createIndexBuilder = (skillParser) => new IndexBuilder(skillParser);
+exports.createIndexBuilder = createIndexBuilder;
+//# sourceMappingURL=IndexBuilder.js.map

package/dist/services/Logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 日志服务
+ */
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export declare class Logger {
+    private level;
+    setLevel(level: LogLevel): void;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: any): void;
+    private shouldLog;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/services/Logger.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * 日志服务
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["WARN"] = "WARN";
+    LogLevel["ERROR"] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        this.level = LogLevel.INFO;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    debug(message, data) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            console.log(`[DEBUG] ${message}`, data || '');
+        }
+    }
+    info(message, data) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            console.log(`[INFO] ${message}`, data || '');
+        }
+    }
+    warn(message, data) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            console.warn(`[WARN] ${message}`, data || '');
+        }
+    }
+    error(message, error) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            console.error(`[ERROR] ${message}`, error || '');
+        }
+    }
+    shouldLog(level) {
+        const levels = [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR];
+        return levels.indexOf(level) >= levels.indexOf(this.level);
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();
+//# sourceMappingURL=Logger.js.map

package/dist/services/ProjectAssetRegistry.d.ts

@@ -0,0 +1,12 @@
+export type ProjectAssetStrategy = 'direct_copy' | 'template_generated' | 'runtime_generated';
+export interface DirectCopyProjectAssetDefinition {
+    id: string;
+    category: 'tooling' | 'conventions' | 'ai_guidance' | 'hooks';
+    description: string;
+    targetRelativePath: string;
+    overwritePolicy: 'if_missing';
+    localizedSources?: Partial<Record<'zh-CN' | 'en-US', string>>;
+    sourceRelativePaths?: string[];
+}
+export declare const DIRECT_COPY_PROJECT_ASSETS: DirectCopyProjectAssetDefinition[];
+//# sourceMappingURL=ProjectAssetRegistry.d.ts.map

package/dist/services/ProjectAssetRegistry.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIRECT_COPY_PROJECT_ASSETS = void 0;
+exports.DIRECT_COPY_PROJECT_ASSETS = [
+    {
+        id: 'ai-guide',
+        category: 'ai_guidance',
+        description: 'Project-adopted AI guide copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/ai-guide.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/for-ai/zh-CN/ai-guide.md',
+            'en-US': 'assets/for-ai/en-US/ai-guide.md',
+        },
+    },
+    {
+        id: 'execution-protocol',
+        category: 'ai_guidance',
+        description: 'Project-adopted execution protocol copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/execution-protocol.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/for-ai/zh-CN/execution-protocol.md',
+            'en-US': 'assets/for-ai/en-US/execution-protocol.md',
+        },
+    },
+    {
+        id: 'build-index-script',
+        category: 'tooling',
+        description: 'Rebuild script for SKILL.index.json.',
+        targetRelativePath: 'build-index-auto.cjs',
+        overwritePolicy: 'if_missing',
+        sourceRelativePaths: ['src/tools/build-index.js', 'dist/tools/build-index.js'],
+    },
+    {
+        id: 'project-naming-conventions',
+        category: 'conventions',
+        description: 'Project-adopted naming conventions copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/naming-conventions.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/project-conventions/zh-CN/naming-conventions.md',
+            'en-US': 'assets/project-conventions/en-US/naming-conventions.md',
+        },
+    },
+    {
+        id: 'project-skill-conventions',
+        category: 'conventions',
+        description: 'Project-adopted layered SKILL conventions copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/skill-conventions.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/project-conventions/zh-CN/skill-conventions.md',
+            'en-US': 'assets/project-conventions/en-US/skill-conventions.md',
+        },
+    },
+    {
+        id: 'project-development-guide',
+        category: 'conventions',
+        description: 'Project-adopted development guide copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/development-guide.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/project-conventions/zh-CN/development-guide.md',
+            'en-US': 'assets/project-conventions/en-US/development-guide.md',
+        },
+    },
+    {
+        id: 'project-workflow-conventions',
+        category: 'conventions',
+        description: 'Project-adopted workflow and change execution conventions copied from the OSpec mother spec.',
+        targetRelativePath: 'for-ai/workflow-conventions.md',
+        overwritePolicy: 'if_missing',
+        localizedSources: {
+            'zh-CN': 'assets/project-conventions/zh-CN/workflow-conventions.md',
+            'en-US': 'assets/project-conventions/en-US/workflow-conventions.md',
+        },
+    },
+    {
+        id: 'hook-template-pre-commit',
+        category: 'hooks',
+        description: 'Template for the OSpec pre-commit hook.',
+        targetRelativePath: '.ospec/templates/hooks/pre-commit',
+        overwritePolicy: 'if_missing',
+        sourceRelativePaths: ['assets/git-hooks/pre-commit'],
+    },
+    {
+        id: 'hook-template-post-merge',
+        category: 'hooks',
+        description: 'Template for the OSpec post-merge hook.',
+        targetRelativePath: '.ospec/templates/hooks/post-merge',
+        overwritePolicy: 'if_missing',
+        sourceRelativePaths: ['assets/git-hooks/post-merge'],
+    },
+];
+//# sourceMappingURL=ProjectAssetRegistry.js.map

package/dist/services/ProjectAssetService.d.ts

@@ -0,0 +1,49 @@
+import { FileService } from './FileService';
+import { DirectCopyProjectAssetDefinition } from './ProjectAssetRegistry';
+interface AssetManifestOptions {
+    documentLanguage?: string;
+    templateGeneratedPaths: string[];
+    runtimeGeneratedPaths: string[];
+}
+export declare class ProjectAssetService {
+    private readonly fileService;
+    constructor(fileService: FileService);
+    getDirectCopyAssets(): DirectCopyProjectAssetDefinition[];
+    getDirectCopyTargetPaths(): string[];
+    getAssetPlan(documentLanguage?: string): {
+        directCopyFiles: string[];
+        templateGeneratedFiles: string[];
+        runtimeGeneratedFiles: string[];
+        localizedCopySources: Array<{
+            targetRelativePath: string;
+            sourceRelativePath: string;
+        }>;
+    };
+    installDirectCopyAssets(rootDir: string, documentLanguage?: string): Promise<{
+        created: string[];
+        skipped: string[];
+    }>;
+    syncDirectCopyAssets(rootDir: string, documentLanguage?: string, options?: {
+        targetRelativePaths?: string[];
+    }): Promise<{
+        created: string[];
+        refreshed: string[];
+        skipped: string[];
+    }>;
+    installGitHooks(rootDir: string, hookConfig?: {
+        'pre-commit': boolean;
+        'post-merge': boolean;
+    }): Promise<{
+        installed: string[];
+        skipped: string[];
+    }>;
+    writeAssetManifest(rootDir: string, options: AssetManifestOptions): Promise<void>;
+    private resolveSourceRelativePath;
+    private resolveStaticSourceHint;
+    private normalizePaths;
+    private getPackageRoot;
+    private isOSpecManagedHook;
+}
+export declare const createProjectAssetService: (fileService: FileService) => ProjectAssetService;
+export {};
+//# sourceMappingURL=ProjectAssetService.d.ts.map

package/dist/services/ProjectAssetService.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectAssetService = exports.ProjectAssetService = void 0;
+const path_1 = __importDefault(require("path"));
+const ProjectAssetRegistry_1 = require("./ProjectAssetRegistry");
+class ProjectAssetService {
+    constructor(fileService) {
+        this.fileService = fileService;
+    }
+    getDirectCopyAssets() {
+        return ProjectAssetRegistry_1.DIRECT_COPY_PROJECT_ASSETS;
+    }
+    getDirectCopyTargetPaths() {
+        return this.getDirectCopyAssets().map(asset => asset.targetRelativePath);
+    }
+    getAssetPlan(documentLanguage) {
+        return {
+            directCopyFiles: this.getDirectCopyTargetPaths(),
+            templateGeneratedFiles: [],
+            runtimeGeneratedFiles: [],
+            localizedCopySources: this.getDirectCopyAssets().map(asset => ({
+                targetRelativePath: asset.targetRelativePath,
+                sourceRelativePath: this.resolveStaticSourceHint(asset, documentLanguage),
+            })),
+        };
+    }
+    async installDirectCopyAssets(rootDir, documentLanguage) {
+        const created = [];
+        const skipped = [];
+        for (const asset of this.getDirectCopyAssets()) {
+            const targetPath = path_1.default.join(rootDir, ...asset.targetRelativePath.split('/'));
+            if (await this.fileService.exists(targetPath)) {
+                skipped.push(asset.targetRelativePath);
+                continue;
+            }
+            const sourceRelativePath = await this.resolveSourceRelativePath(asset, documentLanguage);
+            const sourcePath = path_1.default.join(this.getPackageRoot(), ...sourceRelativePath.split('/'));
+            await this.fileService.copy(sourcePath, targetPath);
+            created.push(asset.targetRelativePath);
+        }
+        return { created, skipped };
+    }
+    async syncDirectCopyAssets(rootDir, documentLanguage, options = {}) {
+        const created = [];
+        const refreshed = [];
+        const skipped = [];
+        const targetFilter = Array.isArray(options.targetRelativePaths)
+            ? new Set(this.normalizePaths(options.targetRelativePaths))
+            : null;
+        for (const asset of this.getDirectCopyAssets()) {
+            if (targetFilter && !targetFilter.has(asset.targetRelativePath)) {
+                continue;
+            }
+            const targetPath = path_1.default.join(rootDir, ...asset.targetRelativePath.split('/'));
+            const sourceRelativePath = await this.resolveSourceRelativePath(asset, documentLanguage);
+            const sourcePath = path_1.default.join(this.getPackageRoot(), ...sourceRelativePath.split('/'));
+            const sourceContent = await this.fileService.readFile(sourcePath);
+            if (!(await this.fileService.exists(targetPath))) {
+                await this.fileService.writeFile(targetPath, sourceContent);
+                created.push(asset.targetRelativePath);
+                continue;
+            }
+            const targetContent = await this.fileService.readFile(targetPath);
+            if (targetContent === sourceContent) {
+                skipped.push(asset.targetRelativePath);
+                continue;
+            }
+            await this.fileService.writeFile(targetPath, sourceContent);
+            refreshed.push(asset.targetRelativePath);
+        }
+        return { created, refreshed, skipped };
+    }
+    async installGitHooks(rootDir, hookConfig) {
+        const installed = [];
+        const skipped = [];
+        const gitHooksDir = path_1.default.join(rootDir, '.git', 'hooks');
+        if (!(await this.fileService.exists(gitHooksDir))) {
+            return { installed, skipped };
+        }
+        const hooks = [
+            {
+                enabled: hookConfig?.['pre-commit'] !== false,
+                sourceRelativePath: '.ospec/templates/hooks/pre-commit',
+                targetRelativePath: '.git/hooks/pre-commit',
+            },
+            {
+                enabled: hookConfig?.['post-merge'] !== false,
+                sourceRelativePath: '.ospec/templates/hooks/post-merge',
+                targetRelativePath: '.git/hooks/post-merge',
+            },
+        ];
+        for (const hook of hooks) {
+            if (!hook.enabled) {
+                continue;
+            }
+            const sourcePath = path_1.default.join(rootDir, ...hook.sourceRelativePath.split('/'));
+            const targetPath = path_1.default.join(rootDir, ...hook.targetRelativePath.split('/'));
+            if (!(await this.fileService.exists(sourcePath))) {
+                skipped.push(hook.targetRelativePath);
+                continue;
+            }
+            const sourceContent = await this.fileService.readFile(sourcePath);
+            const targetExists = await this.fileService.exists(targetPath);
+            if (targetExists) {
+                const targetContent = await this.fileService.readFile(targetPath);
+                if (targetContent === sourceContent) {
+                    skipped.push(hook.targetRelativePath);
+                    continue;
+                }
+                if (!this.isOSpecManagedHook(targetContent)) {
+                    skipped.push(hook.targetRelativePath);
+                    continue;
+                }
+            }
+            await this.fileService.writeFile(targetPath, sourceContent);
+            installed.push(hook.targetRelativePath);
+        }
+        return { installed, skipped };
+    }
+    async writeAssetManifest(rootDir, options) {
+        const copyEntries = await Promise.all(this.getDirectCopyAssets().map(async (asset) => {
+            const targetPath = path_1.default.join(rootDir, ...asset.targetRelativePath.split('/'));
+            return {
+                id: asset.id,
+                strategy: 'direct_copy',
+                category: asset.category,
+                description: asset.description,
+                targetRelativePath: asset.targetRelativePath,
+                sourceRelativePath: await this.resolveSourceRelativePath(asset, options.documentLanguage),
+                overwritePolicy: asset.overwritePolicy,
+                exists: await this.fileService.exists(targetPath),
+            };
+        }));
+        const templateEntries = await Promise.all(this.normalizePaths(options.templateGeneratedPaths).map(async (targetRelativePath) => ({
+            id: `generated:${targetRelativePath}`,
+            strategy: 'template_generated',
+            category: 'templates',
+            description: 'Generated from OSpec template builders during project initialization.',
+            targetRelativePath,
+            sourceRelativePath: null,
+            overwritePolicy: 'if_missing',
+            exists: await this.fileService.exists(path_1.default.join(rootDir, ...targetRelativePath.split('/'))),
+        })));
+        const runtimeEntries = await Promise.all(this.normalizePaths(options.runtimeGeneratedPaths).map(async (targetRelativePath) => ({
+            id: `runtime:${targetRelativePath}`,
+            strategy: 'runtime_generated',
+            category: 'runtime',
+            description: 'Generated by OSpec at runtime or during index/config initialization.',
+            targetRelativePath,
+            sourceRelativePath: null,
+            overwritePolicy: 'rebuild',
+            exists: targetRelativePath === '.ospec/asset-sources.json'
+                ? true
+                : await this.fileService.exists(path_1.default.join(rootDir, ...targetRelativePath.split('/'))),
+        })));
+        const assets = [...copyEntries, ...templateEntries, ...runtimeEntries];
+        const manifestAsset = assets.find(asset => asset.targetRelativePath === '.ospec/asset-sources.json');
+        if (manifestAsset) {
+            manifestAsset.exists = true;
+        }
+        const manifest = {
+            version: '1.0',
+            generatedAt: new Date().toISOString(),
+            documentLanguage: options.documentLanguage || 'zh-CN',
+            assets,
+            summary: {
+                directCopy: copyEntries.length,
+                templateGenerated: templateEntries.length,
+                runtimeGenerated: runtimeEntries.length,
+            },
+        };
+        await this.fileService.writeJSON(path_1.default.join(rootDir, '.ospec', 'asset-sources.json'), manifest);
+    }
+    async resolveSourceRelativePath(asset, documentLanguage) {
+        const candidates = [];
+        if (documentLanguage && asset.localizedSources?.[documentLanguage]) {
+            candidates.push(asset.localizedSources[documentLanguage]);
+        }
+        if (asset.localizedSources?.['zh-CN']) {
+            candidates.push(asset.localizedSources['zh-CN']);
+        }
+        if (asset.sourceRelativePaths) {
+            candidates.push(...asset.sourceRelativePaths);
+        }
+        for (const candidate of candidates) {
+            const absolutePath = path_1.default.join(this.getPackageRoot(), ...candidate.split('/'));
+            if (await this.fileService.exists(absolutePath)) {
+                return candidate;
+            }
+        }
+        throw new Error(`Unable to resolve packaged project asset: ${asset.id}`);
+    }
+    resolveStaticSourceHint(asset, documentLanguage) {
+        if (documentLanguage && asset.localizedSources?.[documentLanguage]) {
+            return asset.localizedSources[documentLanguage];
+        }
+        if (asset.localizedSources?.['zh-CN']) {
+            return asset.localizedSources['zh-CN'];
+        }
+        if (asset.sourceRelativePaths?.[0]) {
+            return asset.sourceRelativePaths[0];
+        }
+        return '';
+    }
+    normalizePaths(paths) {
+        return Array.from(new Set(paths
+            .map(item => item.replace(/\\/g, '/'))
+            .filter(Boolean))).sort((left, right) => left.localeCompare(right));
+    }
+    getPackageRoot() {
+        return path_1.default.resolve(__dirname, '../..');
+    }
+    isOSpecManagedHook(content) {
+        return content.includes('build-index-auto.cjs') || content.includes('build-index-auto.js') || content.includes('[ospec]');
+    }
+}
+exports.ProjectAssetService = ProjectAssetService;
+const createProjectAssetService = (fileService) => new ProjectAssetService(fileService);
+exports.createProjectAssetService = createProjectAssetService;
+//# sourceMappingURL=ProjectAssetService.js.map

package/dist/services/ProjectScaffoldCommandService.d.ts

@@ -0,0 +1,73 @@
+import { FileService } from './FileService';
+import { Logger } from './Logger';
+import { NormalizedProjectBootstrapInput } from './TemplateEngine';
+import { ProjectScaffoldPlan } from './ProjectScaffoldService';
+export interface ProjectScaffoldCommandStep {
+    id: string;
+    title: string;
+    command: string;
+    args: string[];
+    shellCommand: string;
+    description: string;
+    phase: 'install';
+}
+export interface ProjectScaffoldCommandPlan {
+    presetId: string;
+    autoExecute: boolean;
+    steps: ProjectScaffoldCommandStep[];
+    deferredMessage: string;
+}
+export interface ProjectScaffoldCommandStepResult {
+    id: string;
+    title: string;
+    shellCommand: string;
+    status: 'completed' | 'failed' | 'skipped';
+    exitCode: number | null;
+    durationMs: number;
+    stdoutSnippet: string;
+    stderrSnippet: string;
+}
+export interface ProjectScaffoldCommandExecutionResult {
+    status: 'skipped' | 'completed' | 'failed';
+    steps: ProjectScaffoldCommandStepResult[];
+    recoveryFilePath: string | null;
+}
+export interface ProjectBootstrapRecoveryRecord {
+    generatedAt: string;
+    projectPresetId: string | null;
+    projectName: string;
+    failedStep: {
+        id: string;
+        title: string;
+        shellCommand: string;
+    };
+    createdArtifacts: {
+        scaffoldFiles: string[];
+        scaffoldDirectories: string[];
+        directCopyFiles: string[];
+        hooks: string[];
+    };
+    remediation: string[];
+}
+interface RecoveryInput {
+    normalized: NormalizedProjectBootstrapInput;
+    failedStep: ProjectScaffoldCommandStepResult;
+    scaffoldCreatedFiles: string[];
+    scaffoldCreatedDirectories: string[];
+    directCopyCreatedFiles: string[];
+    hookInstalledFiles: string[];
+}
+export declare class ProjectScaffoldCommandService {
+    private readonly fileService;
+    private readonly logger;
+    constructor(fileService: FileService, logger: Logger);
+    getPlan(normalized: NormalizedProjectBootstrapInput, scaffoldPlan: ProjectScaffoldPlan | null): ProjectScaffoldCommandPlan | null;
+    executePlan(rootDir: string, plan: ProjectScaffoldCommandPlan | null): Promise<ProjectScaffoldCommandExecutionResult>;
+    writeRecoveryRecord(rootDir: string, input: RecoveryInput): Promise<string>;
+    private executeStep;
+    private resolvePackageManagerRunner;
+    private limitOutput;
+}
+export declare const createProjectScaffoldCommandService: (fileService: FileService, logger: Logger) => ProjectScaffoldCommandService;
+export {};
+//# sourceMappingURL=ProjectScaffoldCommandService.d.ts.map