@clawplays/ospec-cli 0.1.1

package/dist/commands/SkillsCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './BaseCommand';
+export declare class SkillsCommand extends BaseCommand {
+    execute(action?: string, projectPath?: string): Promise<void>;
+}
+//# sourceMappingURL=SkillsCommand.d.ts.map

package/dist/commands/SkillsCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillsCommand = void 0;
+const services_1 = require("../services");
+const subcommandHelp_1 = require("../utils/subcommandHelp");
+const BaseCommand_1 = require("./BaseCommand");
+class SkillsCommand extends BaseCommand_1.BaseCommand {
+    async execute(action = 'status', projectPath) {
+        try {
+            if ((0, subcommandHelp_1.isHelpAction)(action)) {
+                this.info((0, subcommandHelp_1.getSkillsHelpText)());
+                return;
+            }
+            const targetPath = projectPath || process.cwd();
+            switch (action) {
+                case 'status': {
+                    const skills = await services_1.services.projectService.getSkillsStatus(targetPath);
+                    console.log('\nSkills Status');
+                    console.log('=============\n');
+                    console.log(`Skill files: ${skills.existing}/${skills.totalSkillFiles}`);
+                    console.log(`Index: ${skills.skillIndex.exists ? 'present' : 'missing'}`);
+                    console.log(`Index needs rebuild: ${skills.skillIndex.needsRebuild ? 'yes' : 'no'}`);
+                    if (skills.skillIndex.updatedAt) {
+                        console.log(`Index updated: ${skills.skillIndex.updatedAt}`);
+                    }
+                    if (skills.skillIndex.latestSourceUpdatedAt) {
+                        console.log(`Latest skill update: ${skills.skillIndex.latestSourceUpdatedAt}`);
+                    }
+                    if (skills.skillIndex.stats) {
+                        console.log(`Index stats: ${skills.skillIndex.stats.totalFiles} files, ${skills.skillIndex.stats.totalModules} modules, ${skills.skillIndex.stats.totalSections} sections`);
+                    }
+                    if (skills.skillIndex.reasons.length > 0) {
+                        console.log('Index rebuild reasons:');
+                        for (const reason of skills.skillIndex.reasons) {
+                            console.log(`  - ${reason}`);
+                        }
+                    }
+                    console.log('\nRoot skills:');
+                    for (const skill of skills.rootSkills) {
+                        console.log(`  ${skill.exists ? '✓' : '✗'} ${skill.path}`);
+                    }
+                    if (skills.moduleSkills.length > 0) {
+                        console.log('\nModule skills:');
+                        for (const skill of skills.moduleSkills) {
+                            console.log(`  ${skill.exists ? '✓' : '✗'} ${skill.path}`);
+                        }
+                    }
+                    if (skills.missingRecommended.length > 0) {
+                        console.log('\nMissing recommended skills:');
+                        for (const item of skills.missingRecommended) {
+                            console.log(`  - ${item}`);
+                        }
+                    }
+                    console.log('');
+                    break;
+                }
+                default:
+                    this.info((0, subcommandHelp_1.getSkillsHelpText)());
+            }
+        }
+        catch (error) {
+            this.error(`Skills command failed: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.SkillsCommand = SkillsCommand;
+//# sourceMappingURL=SkillsCommand.js.map

package/dist/commands/StatusCommand.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from './BaseCommand';
+export declare class StatusCommand extends BaseCommand {
+    execute(projectPath?: string): Promise<void>;
+    private getRecommendedNextSteps;
+}
+//# sourceMappingURL=StatusCommand.d.ts.map

package/dist/commands/StatusCommand.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusCommand = void 0;
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+class StatusCommand extends BaseCommand_1.BaseCommand {
+    async execute(projectPath) {
+        try {
+            const targetPath = projectPath || process.cwd();
+            this.logger.info(`Getting status for ${targetPath}`);
+            const [structure, summary, docs, skills, execution, changes, queuedChanges, runReport] = await Promise.all([
+                services_1.services.projectService.detectProjectStructure(targetPath),
+                services_1.services.projectService.getProjectSummary(targetPath),
+                services_1.services.projectService.getDocsStatus(targetPath),
+                services_1.services.projectService.getSkillsStatus(targetPath),
+                services_1.services.projectService.getExecutionStatus(targetPath),
+                services_1.services.projectService.getActiveChangeStatusReport(targetPath),
+                services_1.services.queueService.getQueuedChanges(targetPath),
+                services_1.services.runService.getStatusReport(targetPath),
+            ]);
+            console.log('\nProject Status');
+            console.log('==============\n');
+            console.log(`Name: ${summary.name}`);
+            console.log(`Path: ${summary.path}`);
+            console.log(`Mode: ${summary.mode ?? 'uninitialized'}`);
+            console.log(`Initialized: ${summary.initialized ? 'yes' : 'no'}`);
+            console.log(`Structure Level: ${summary.structureLevel}`);
+            console.log(`Active Changes: ${summary.activeChangeCount}`);
+            console.log(`Queued Changes: ${queuedChanges.length}`);
+            console.log('\nStructure');
+            console.log('---------');
+            console.log(`Missing required: ${structure.missingRequired.length}`);
+            if (structure.missingRequired.length > 0) {
+                for (const item of structure.missingRequired) {
+                    console.log(`  - ${item}`);
+                }
+            }
+            console.log(`Missing recommended: ${structure.missingRecommended.length}`);
+            if (structure.missingRecommended.length > 0) {
+                for (const item of structure.missingRecommended.slice(0, 10)) {
+                    console.log(`  - ${item}`);
+                }
+            }
+            console.log('\nUpgrade suggestions:');
+            for (const suggestion of structure.upgradeSuggestions) {
+                console.log(`  - ${suggestion.title}: ${suggestion.description}`);
+                for (const item of suggestion.paths.slice(0, 5)) {
+                    console.log(`      ${item}`);
+                }
+            }
+            console.log('\nDocs');
+            console.log('----');
+            console.log(`Coverage: ${docs.coverage}% (${docs.existing}/${docs.total})`);
+            console.log(`Missing required docs: ${docs.missingRequired.length}`);
+            console.log('\nSkills');
+            console.log('------');
+            console.log(`Skill files: ${skills.existing}/${skills.totalSkillFiles}`);
+            console.log(`Skill index: ${skills.skillIndex.exists ? 'present' : 'missing'}`);
+            if (skills.skillIndex.stats) {
+                console.log(`Index stats: ${skills.skillIndex.stats.totalFiles} files, ${skills.skillIndex.stats.totalSections} sections`);
+            }
+            console.log('\nExecution');
+            console.log('---------');
+            console.log(`Active changes: ${execution.totalActiveChanges}`);
+            console.log(`Queued changes: ${queuedChanges.length}`);
+            for (const [status, count] of Object.entries(execution.byStatus)) {
+                console.log(`  ${status}: ${count}`);
+            }
+            console.log(`Protocol summary: PASS ${changes.totals.pass} | WARN ${changes.totals.warn} | FAIL ${changes.totals.fail}`);
+            if (execution.activeChanges.length > 0) {
+                console.log('\nCurrent changes:');
+                for (const change of execution.activeChanges) {
+                    console.log(`  - ${change.name} [${change.status}] ${change.progress}%`);
+                }
+            }
+            if (queuedChanges.length > 0) {
+                console.log('\nQueued changes:');
+                for (const change of queuedChanges) {
+                    console.log(`  - ${change.name} [${change.status}]`);
+                }
+            }
+            if (runReport.currentRun) {
+                console.log('\nQueue Run');
+                console.log('---------');
+                console.log(`Status: ${runReport.currentRun.status}`);
+                console.log(`Profile: ${runReport.currentRun.profileId}`);
+                console.log(`Stage: ${runReport.stage ?? 'unknown'}`);
+                if (runReport.nextInstruction) {
+                    console.log(`Next: ${runReport.nextInstruction}`);
+                }
+            }
+            console.log('\nRecommended Next Step');
+            console.log('---------------------');
+            for (const step of this.getRecommendedNextSteps(targetPath, structure, docs, execution, queuedChanges, runReport)) {
+                console.log(`  - ${step}`);
+            }
+            console.log('');
+        }
+        catch (error) {
+            this.error(`Failed to get status: ${error}`);
+            throw error;
+        }
+    }
+    getRecommendedNextSteps(projectPath, structure, docs, execution, queuedChanges, runReport) {
+        if (!structure.initialized) {
+            return [
+                `Run "ospec init ${projectPath}" to initialize the OSpec protocol shell.`,
+            ];
+        }
+        if (docs.missingRequired.length > 0 || docs.coverage < 100) {
+            return [
+                'The OSpec protocol shell is ready, but the project knowledge layer is still incomplete.',
+                `Run "ospec docs generate ${projectPath}" to backfill the default project knowledge layer. This still will not apply business scaffold or generate docs/project/bootstrap-summary.md.`,
+            ];
+        }
+        if (execution.totalActiveChanges === 0 && queuedChanges.length === 0) {
+            return [
+                `Or run "ospec new <change-name> ${projectPath}" if you want to create the first change from CLI.`,
+            ];
+        }
+        if (execution.totalActiveChanges === 0 && queuedChanges.length > 0) {
+            return [
+                `There is no active change right now, but ${queuedChanges.length} queued change(s) are waiting.`,
+                `Run "ospec queue next ${projectPath}" if you want to activate the next queued change manually.`,
+                `Or run "ospec run start ${projectPath}" to begin explicit queue tracking.`,
+            ];
+        }
+        const currentChange = execution.activeChanges[0];
+        const nextSteps = [
+            `Continue the active change "${currentChange.name}" with "ospec progress ${projectPath}/changes/active/${currentChange.name}".`,
+            `Run "ospec verify ${projectPath}/changes/active/${currentChange.name}" before trying to archive it.`,
+        ];
+        if (queuedChanges.length > 0) {
+            nextSteps.push(`There are ${queuedChanges.length} queued change(s) waiting behind the active one. Use "ospec run ${runReport.currentRun ? 'step' : 'start'} ${projectPath}" when you want explicit queue progression.`);
+        }
+        return nextSteps;
+    }
+}
+exports.StatusCommand = StatusCommand;
+//# sourceMappingURL=StatusCommand.js.map

package/dist/commands/UpdateCommand.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from './BaseCommand';
+export declare class UpdateCommand extends BaseCommand {
+    execute(rootDir?: string): Promise<void>;
+    private syncProjectTooling;
+    private syncInstalledSkills;
+    private shouldSyncClaudeSkills;
+}
+//# sourceMappingURL=UpdateCommand.d.ts.map

package/dist/commands/UpdateCommand.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCommand = void 0;
+const os_1 = require("os");
+const path_1 = require("path");
+const services_1 = require("../services");
+const BaseCommand_1 = require("./BaseCommand");
+const PluginsCommand_1 = require("./PluginsCommand");
+const SkillCommand_1 = require("./SkillCommand");
+class UpdateCommand extends BaseCommand_1.BaseCommand {
+    async execute(rootDir) {
+        const targetPath = rootDir ? (0, path_1.resolve)(rootDir) : process.cwd();
+        const structure = await services_1.services.projectService.detectProjectStructure(targetPath);
+        if (!structure.initialized) {
+            throw new Error('Project is not initialized. Run "ospec init" first.');
+        }
+        this.info(`Updating OSpec project at ${targetPath}`);
+        const protocolResult = await services_1.services.projectService.syncProtocolGuidance(targetPath);
+        const toolingResult = await this.syncProjectTooling(targetPath, protocolResult.documentLanguage);
+        const pluginResult = await this.syncEnabledPluginAssets(targetPath);
+        const skillResult = await this.syncInstalledSkills();
+        const refreshedFiles = [...protocolResult.refreshedFiles, ...toolingResult.refreshedFiles, ...pluginResult.refreshedFiles];
+        const createdFiles = [...protocolResult.createdFiles, ...toolingResult.createdFiles, ...pluginResult.createdFiles];
+        const skippedFiles = [...protocolResult.skippedFiles, ...toolingResult.skippedFiles, ...pluginResult.skippedFiles];
+        this.success(`Updated OSpec assets for ${protocolResult.projectName}`);
+        this.info(`  document language: ${protocolResult.documentLanguage}`);
+        this.info(`  created: ${createdFiles.length}`);
+        this.info(`  refreshed: ${refreshedFiles.length}`);
+        this.info(`  skipped: ${skippedFiles.length}`);
+        if (toolingResult.hookInstalledFiles.length > 0) {
+            this.info(`  git hooks refreshed: ${toolingResult.hookInstalledFiles.join(', ')}`);
+        }
+        this.info(`  codex skill: ${skillResult.codex.targetDir}`);
+        if (skillResult.claude) {
+            this.info(`  claude skill: ${skillResult.claude.targetDir}`);
+        }
+        if (pluginResult.enabledPlugins.length > 0) {
+            this.info(`  plugin assets refreshed: ${pluginResult.enabledPlugins.join(', ')}`);
+        }
+        if (pluginResult.configSaved) {
+            this.info('  plugin config normalized: .skillrc');
+        }
+        this.info('  note: update refreshes protocol docs, tooling, hooks, managed skills, and managed assets for already-enabled plugins');
+        this.info('  note: it does not enable, disable, or migrate existing changes automatically');
+    }
+    async syncProjectTooling(rootDir, documentLanguage) {
+        const toolingPaths = [
+            'build-index-auto.cjs',
+            '.ospec/templates/hooks/pre-commit',
+            '.ospec/templates/hooks/post-merge',
+        ];
+        const directCopyResult = await services_1.services.projectAssetService.syncDirectCopyAssets(rootDir, documentLanguage, {
+            targetRelativePaths: toolingPaths,
+        });
+        const config = await services_1.services.configManager.loadConfig(rootDir);
+        const hookInstallResult = await services_1.services.projectAssetService.installGitHooks(rootDir, config.hooks);
+        return {
+            createdFiles: [...directCopyResult.created],
+            refreshedFiles: [...directCopyResult.refreshed],
+            skippedFiles: [...directCopyResult.skipped],
+            hookInstalledFiles: [...hookInstallResult.installed],
+        };
+    }
+    async syncEnabledPluginAssets(rootDir) {
+        const rawConfig = await services_1.services.fileService.readJSON((0, path_1.join)(rootDir, '.skillrc'));
+        const config = await services_1.services.configManager.loadConfig(rootDir);
+        const nextConfig = JSON.parse(JSON.stringify(config));
+        const pluginsCommand = new PluginsCommand_1.PluginsCommand();
+        const createdFiles = [];
+        const refreshedFiles = [];
+        const skippedFiles = [];
+        const enabledPlugins = [];
+        let configChanged = false;
+        const hasLegacyPluginKeys = Boolean(rawConfig?.plugins?.['stitch-gemini'] || rawConfig?.plugins?.['stitch-codex']);
+        if (nextConfig.plugins?.stitch?.enabled) {
+            enabledPlugins.push('stitch');
+            configChanged = this.normalizeEnabledStitchPlugin(nextConfig.plugins.stitch, pluginsCommand) || configChanged;
+            const stitchAssets = await this.ensureManagedPluginAssets(rootDir, [
+                '.ospec/plugins/stitch/project.json',
+                '.ospec/plugins/stitch/README.md',
+                '.ospec/plugins/stitch/exports/.gitkeep',
+                '.ospec/plugins/stitch/baselines/.gitkeep',
+                '.ospec/plugins/stitch/cache/.gitkeep',
+            ], async () => {
+                await pluginsCommand.ensureStitchWorkspaceScaffold(rootDir, nextConfig.plugins.stitch);
+            });
+            createdFiles.push(...stitchAssets.createdFiles);
+            skippedFiles.push(...stitchAssets.skippedFiles);
+        }
+        if (nextConfig.plugins?.checkpoint?.enabled) {
+            enabledPlugins.push('checkpoint');
+            configChanged = this.normalizeEnabledCheckpointPlugin(nextConfig.plugins.checkpoint, pluginsCommand) || configChanged;
+            const checkpointAssets = await this.ensureManagedPluginAssets(rootDir, [
+                '.ospec/plugins/checkpoint/routes.yaml',
+                '.ospec/plugins/checkpoint/flows.yaml',
+                '.ospec/plugins/checkpoint/README.md',
+                '.ospec/plugins/checkpoint/baselines/.gitkeep',
+                '.ospec/plugins/checkpoint/auth/.gitkeep',
+                '.ospec/plugins/checkpoint/auth/README.md',
+                '.ospec/plugins/checkpoint/auth/login.example.js',
+                '.ospec/plugins/checkpoint/cache/.gitkeep',
+            ], async () => {
+                await pluginsCommand.ensureCheckpointWorkspaceScaffold(rootDir, nextConfig.plugins.checkpoint);
+            });
+            createdFiles.push(...checkpointAssets.createdFiles);
+            skippedFiles.push(...checkpointAssets.skippedFiles);
+        }
+        if (enabledPlugins.length > 0 && (hasLegacyPluginKeys || configChanged)) {
+            await services_1.services.configManager.saveConfig(rootDir, nextConfig);
+            refreshedFiles.push('.skillrc');
+        }
+        return {
+            createdFiles,
+            refreshedFiles,
+            skippedFiles,
+            enabledPlugins,
+            configSaved: refreshedFiles.includes('.skillrc'),
+        };
+    }
+    normalizeEnabledStitchPlugin(stitchConfig, pluginsCommand) {
+        const before = JSON.stringify(stitchConfig);
+        stitchConfig.runner = stitchConfig.runner || pluginsCommand.createDefaultStitchPluginConfig().runner;
+        stitchConfig.gemini = stitchConfig.gemini || {
+            model: 'gemini-3-flash-preview',
+            auto_switch_on_limit: true,
+            save_on_fallback: true,
+        };
+        stitchConfig.codex = stitchConfig.codex || {
+            model: '',
+            mcp_server: 'stitch',
+        };
+        if (!stitchConfig.provider) {
+            stitchConfig.provider = 'gemini';
+        }
+        const provider = pluginsCommand.getStitchProvider(stitchConfig);
+        if (!stitchConfig.runner.command) {
+            stitchConfig.runner.command = 'node';
+        }
+        if (!Array.isArray(stitchConfig.runner.args) ||
+            stitchConfig.runner.args.length === 0 ||
+            pluginsCommand.isBuiltInGeminiRunner(stitchConfig.runner) ||
+            pluginsCommand.isBuiltInCodexRunner(stitchConfig.runner)) {
+            stitchConfig.runner.args = pluginsCommand.getDefaultRunnerArgs(provider);
+        }
+        if (!stitchConfig.runner.cwd) {
+            stitchConfig.runner.cwd = '${project_path}';
+        }
+        if (typeof stitchConfig.runner.token_env !== 'string' ||
+            (provider === 'gemini' &&
+                pluginsCommand.isBuiltInGeminiRunner(stitchConfig.runner) &&
+                stitchConfig.runner.token_env.trim() === 'STITCH_API_TOKEN')) {
+            stitchConfig.runner.token_env = '';
+        }
+        stitchConfig.capabilities = stitchConfig.capabilities || {};
+        stitchConfig.capabilities.page_design_review = stitchConfig.capabilities.page_design_review || {
+            enabled: false,
+            step: 'stitch_design_review',
+            activate_when_flags: ['ui_change', 'page_design', 'landing_page'],
+        };
+        return before !== JSON.stringify(stitchConfig);
+    }
+    normalizeEnabledCheckpointPlugin(checkpointConfig, pluginsCommand) {
+        const before = JSON.stringify(checkpointConfig);
+        const defaultConfig = pluginsCommand.createDefaultCheckpointPluginConfig();
+        checkpointConfig.runtime = checkpointConfig.runtime || defaultConfig.runtime;
+        checkpointConfig.runner = checkpointConfig.runner || defaultConfig.runner;
+        checkpointConfig.capabilities = checkpointConfig.capabilities || {};
+        checkpointConfig.capabilities.ui_review = checkpointConfig.capabilities.ui_review || {
+            enabled: false,
+            step: 'checkpoint_ui_review',
+            activate_when_flags: ['ui_change', 'page_design', 'landing_page'],
+        };
+        checkpointConfig.capabilities.flow_check = checkpointConfig.capabilities.flow_check || {
+            enabled: false,
+            step: 'checkpoint_flow_check',
+            activate_when_flags: ['feature_flow', 'api_change', 'backend_change', 'integration_change'],
+        };
+        checkpointConfig.stitch_integration = checkpointConfig.stitch_integration || {
+            enabled: true,
+            auto_pass_stitch_review: true,
+        };
+        checkpointConfig.runtime.startup = checkpointConfig.runtime.startup || defaultConfig.runtime.startup;
+        checkpointConfig.runtime.readiness = checkpointConfig.runtime.readiness || defaultConfig.runtime.readiness;
+        checkpointConfig.runtime.auth = checkpointConfig.runtime.auth || defaultConfig.runtime.auth;
+        checkpointConfig.runtime.shutdown = checkpointConfig.runtime.shutdown || defaultConfig.runtime.shutdown;
+        if (!checkpointConfig.runner.command) {
+            checkpointConfig.runner.command = 'node';
+        }
+        if (!Array.isArray(checkpointConfig.runner.args) ||
+            checkpointConfig.runner.args.length === 0 ||
+            pluginsCommand.isBuiltInCheckpointRunner(checkpointConfig.runner)) {
+            checkpointConfig.runner.args = pluginsCommand.getDefaultCheckpointRunnerArgs();
+        }
+        if (!checkpointConfig.runner.cwd) {
+            checkpointConfig.runner.cwd = '${project_path}';
+        }
+        if (typeof checkpointConfig.runner.token_env !== 'string') {
+            checkpointConfig.runner.token_env = '';
+        }
+        return before !== JSON.stringify(checkpointConfig);
+    }
+    async ensureManagedPluginAssets(rootDir, relativePaths, ensureAssets) {
+        const uniqueRelativePaths = Array.from(new Set(relativePaths.map(item => item.replace(/\\/g, '/'))));
+        const beforeMap = {};
+        for (const relativePath of uniqueRelativePaths) {
+            beforeMap[relativePath] = await services_1.services.fileService.exists((0, path_1.join)(rootDir, ...relativePath.split('/')));
+        }
+        await ensureAssets();
+        const createdFiles = [];
+        const skippedFiles = [];
+        for (const relativePath of uniqueRelativePaths) {
+            const exists = await services_1.services.fileService.exists((0, path_1.join)(rootDir, ...relativePath.split('/')));
+            if (!exists) {
+                continue;
+            }
+            if (beforeMap[relativePath]) {
+                skippedFiles.push(relativePath);
+            }
+            else {
+                createdFiles.push(relativePath);
+            }
+        }
+        return { createdFiles, skippedFiles };
+    }
+    async syncInstalledSkills() {
+        const skillCommand = new SkillCommand_1.SkillCommand();
+        const codex = await skillCommand.installSkill('codex', 'ospec-change');
+        const claude = (await this.shouldSyncClaudeSkills()) ? await skillCommand.installSkill('claude', 'ospec-change') : null;
+        return { codex, claude };
+    }
+    resolveProviderHome(provider) {
+        const envHome = provider === 'claude'
+            ? String(process.env.CLAUDE_HOME || '').trim()
+            : String(process.env.CODEX_HOME || '').trim();
+        if (envHome) {
+            return (0, path_1.resolve)(envHome);
+        }
+        return provider === 'claude'
+            ? (0, path_1.join)((0, os_1.homedir)(), '.claude')
+            : (0, path_1.join)((0, os_1.homedir)(), '.codex');
+    }
+    async shouldSyncClaudeSkills() {
+        const claudeHome = this.resolveProviderHome('claude');
+        if (String(process.env.CLAUDE_HOME || '').trim()) {
+            return true;
+        }
+        return services_1.services.fileService.exists(claudeHome);
+    }
+}
+exports.UpdateCommand = UpdateCommand;
+//# sourceMappingURL=UpdateCommand.js.map

package/dist/commands/VerifyCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './BaseCommand';
+export declare class VerifyCommand extends BaseCommand {
+    execute(featurePath?: string): Promise<void>;
+}
+//# sourceMappingURL=VerifyCommand.d.ts.map