@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/cli/program.js

@@ -1,10 +1,11 @@
 import { Command } from 'commander';
 import { createRequire } from 'module';
 import ora from 'ora';
+import chalk from 'chalk';
 import path from 'path';
 import { promises as fs } from 'fs';
-import { AI_TOOLS } from '../core/config.js';
-import { CLI_NAME } from '../core/branding.js';
+import { AI_TOOLS, getToolInstallGuidance } from '../core/config.js';
+import { CLI_NAME, CLI_PRODUCT_NAME } from '../core/branding.js';
 import { UpdateCommand } from '../core/update.js';
 import { ListCommand } from '../core/list.js';
 import { ArchiveCommand } from '../core/archive.js';
@@ -108,6 +109,114 @@ export function createCliProgram(options = {}) {
             return value;
         throw new Error(`Invalid value for --layout: "${value}". Use en-US, legacy, or pt-BR.`);
     }
+    async function detectExistingCodebase(projectRoot) {
+        const markers = [
+            'package.json',
+            'pnpm-workspace.yaml',
+            'tsconfig.json',
+            'pyproject.toml',
+            'requirements.txt',
+            'go.mod',
+            'Cargo.toml',
+            'pom.xml',
+            'build.gradle',
+            'pubspec.yaml',
+            'src',
+            'test',
+            'tests',
+            'docs',
+            'README.md',
+            '.github',
+        ];
+        const entries = await fs.readdir(projectRoot).catch(() => []);
+        const visibleEntries = entries.filter((entry) => !['.sdd', '.git', '.codex', '.claude', '.cursor', '.opencode'].includes(entry));
+        return markers.some((marker) => visibleEntries.includes(marker));
+    }
+    async function resolveInstallPrimaryNextAction(projectRoot) {
+        try {
+            const { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths } = await import('../core/sdd/state.js');
+            const config = await loadProjectSddConfig(projectRoot);
+            const paths = resolveSddPaths(projectRoot, config);
+            const snapshot = await loadStateSnapshot(paths, config);
+            const activeFeature = snapshot.backlog.items.find((item) => item.status === 'IN_PROGRESS');
+            if (activeFeature) {
+                return `${CLI_NAME} sdd context ${activeFeature.id}`;
+            }
+            const readyFeature = snapshot.backlog.items.find((item) => item.status === 'READY');
+            if (readyFeature) {
+                return `${CLI_NAME} sdd start ${readyFeature.id}`;
+            }
+            const openDebate = snapshot.discoveryIndex.records.find((record) => record.type === 'DEB' && record.status === 'OPEN');
+            if (openDebate) {
+                return `${CLI_NAME} sdd decide ${openDebate.id} --outcome epic`;
+            }
+            const hasInsight = snapshot.discoveryIndex.records.some((record) => record.type === 'INS');
+            if (!hasInsight) {
+                return `${CLI_NAME} sdd insight "describe the change or initiative"`;
+            }
+            return `${CLI_NAME} sdd next`;
+        }
+        catch {
+            return `${CLI_NAME} sdd onboard system`;
+        }
+    }
+    function formatInstallDefaults(options) {
+        return {
+            tools: options?.tools ? `explicit:${options.tools}` : 'auto',
+            language: options?.lang ? `explicit:${options.lang}` : 'auto',
+            layout: options?.layout ? `explicit:${options.layout}` : 'auto',
+            frontend: options?.frontend === false ? 'disabled' : 'auto',
+            check: 'rendered',
+            onboard: 'synced',
+            announce: 'synced',
+            legacy: 'warn-only',
+        };
+    }
+    function resolveInstallToolIds(tools) {
+        if (!tools)
+            return [];
+        const raw = tools.trim().toLowerCase();
+        if (!raw || raw === 'none')
+            return [];
+        if (raw === 'all')
+            return availableToolIds;
+        return raw
+            .split(',')
+            .map((token) => token.trim())
+            .filter((token) => token.length > 0);
+    }
+    function displayFullInstallResult(result) {
+        console.log();
+        console.log(chalk.bold(`${CLI_PRODUCT_NAME} Setup Complete`));
+        console.log();
+        console.log(chalk.bold('Default-first engagement:'));
+        console.log(`  Mode: ${result.mode}`);
+        console.log(`  Tools: ${result.defaults.tools}`);
+        for (const note of result.toolNotes) {
+            console.log(`  ${note}`);
+        }
+        console.log(`  Language: ${result.defaults.language}`);
+        console.log(`  Layout: ${result.defaults.layout}`);
+        console.log(`  Frontend: ${result.frontendEnabled ? 'enabled' : 'disabled'} (${result.defaults.frontend})`);
+        console.log(`  Views generated: ${result.rendered ? 'yes' : 'no'}`);
+        console.log(`  Curated skills loaded: ${result.skillsSeeded}`);
+        console.log(`  Local skills generated: ${result.localSkillsMaterialized}`);
+        console.log(`  Tools synced: ${result.syncedTools.length > 0 ? result.syncedTools.join(', ') : 'none detected'}`);
+        if (result.mode === 'existing-codebase') {
+            const updatedKeys = Object.entries(result.contextUpdated)
+                .filter(([, updated]) => updated)
+                .map(([key]) => key);
+            console.log(`  Existing context absorbed: ${updatedKeys.length > 0 ? updatedKeys.join(', ') : 'no structural updates needed'}`);
+        }
+        console.log(`  Compatibility: ${result.defaults.legacy}`);
+        console.log();
+        console.log(chalk.bold('Primary next action:'));
+        console.log(`  ${result.primaryNextAction}`);
+        console.log();
+        console.log(chalk.dim(`Advanced checks: ${CLI_NAME} sdd onboard system | ${CLI_NAME} sdd check --render`));
+        console.log(chalk.dim('Compatibility slash commands may exist for older workflows; prefer CodeSDD SDD commands in .sdd-native projects.'));
+        console.log();
+    }
     async function runInitCommand(targetPath, options) {
         // Validate that the path is a valid directory
         const resolvedPath = path.resolve(targetPath);
@@ -142,15 +251,53 @@ export function createCliProgram(options = {}) {
         await initCommand.execute(targetPath);
     }
     async function runFullInstallCommand(targetPath, options) {
-        await runInitCommand(targetPath, options);
-        const { SddInitCommand } = await import('../core/sdd/init.js');
+        const resolvedPath = path.resolve(targetPath);
+        const existingCodebase = await detectExistingCodebase(resolvedPath);
+        await runInitCommand(targetPath, {
+            ...options,
+            allowNoToolsFallback: true,
+            interactive: false,
+            silent: true,
+        });
+        const { SddInitCommand, SddInitContextCommand } = await import('../core/sdd/init.js');
+        const language = normalizeSddLang(options?.lang);
+        const layout = normalizeSddLayout(options?.layout);
+        const frontendEnabled = options?.frontend ?? true;
         const sddInitCommand = new SddInitCommand();
-        await sddInitCommand.execute(targetPath, {
-            frontendEnabled: options?.frontend ?? true,
-            language: normalizeSddLang(options?.lang),
-            layout: normalizeSddLayout(options?.layout),
-            render: true,
+        const initResult = await sddInitCommand.execute(targetPath, {
+            frontendEnabled,
+            language,
+            layout,
+            render: !existingCodebase,
         });
+        let contextUpdated = {};
+        let rendered = initResult.rendered;
+        if (existingCodebase) {
+            const contextCommand = new SddInitContextCommand();
+            const contextResult = await contextCommand.execute(targetPath, {
+                mode: 'merge',
+                deep: true,
+                render: true,
+                frontendEnabled,
+                language,
+                layout,
+            });
+            contextUpdated = contextResult.sddBootstrap.updated;
+            rendered = contextResult.rendered;
+        }
+        return {
+            memoryDir: initResult.memoryDir,
+            frontendEnabled: initResult.frontendEnabled,
+            rendered,
+            skillsSeeded: initResult.skillsSeeded,
+            localSkillsMaterialized: initResult.localSkillsMaterialized,
+            syncedTools: initResult.syncedTools,
+            mode: existingCodebase ? 'existing-codebase' : 'new-project',
+            contextUpdated,
+            defaults: formatInstallDefaults(options),
+            toolNotes: getToolInstallGuidance(resolveInstallToolIds(options?.tools)),
+            primaryNextAction: await resolveInstallPrimaryNextAction(resolvedPath),
+        };
     }
     async function runReloadCommand(targetPath, options) {
         await runInitCommand(targetPath, {
@@ -254,7 +401,8 @@ export function createCliProgram(options = {}) {
         .option('--no-frontend', 'Disable frontend module in the SDD bootstrap')
         .action(async (targetPath = '.', options) => {
         try {
-            await runFullInstallCommand(targetPath, options);
+            const result = await runFullInstallCommand(targetPath, options);
+            displayFullInstallResult(result);
         }
         catch (error) {
             console.log();
@@ -640,6 +788,27 @@ export function createCliProgram(options = {}) {
 }
 export async function runCli(argv = process.argv) {
     const program = createCliProgram();
-    await program.parseAsync(argv);
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        const rawMessage = error instanceof Error ? error.message : `${error}`;
+        const formattedMessage = /^error:/i.test(rawMessage) ? rawMessage : `Error: ${rawMessage}`;
+        const errorExitCode = typeof error === 'object' &&
+            error !== null &&
+            'exitCode' in error &&
+            typeof error.exitCode === 'number'
+            ? error.exitCode
+            : undefined;
+        console.error(formattedMessage);
+        if (typeof process.exitCode === 'number' && process.exitCode !== 0) {
+            return;
+        }
+        if (typeof errorExitCode === 'number' && Number.isInteger(errorExitCode) && errorExitCode > 0) {
+            process.exitCode = errorExitCode;
+            return;
+        }
+        process.exitCode = 1;
+    }
 }
 //# sourceMappingURL=program.js.map

package/dist/commands/config.js

@@ -7,8 +7,11 @@ import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatV
 import { CORE_WORKFLOWS, ALL_WORKFLOWS, getProfileWorkflows } from '../core/profiles.js';
 import { hasProjectConfigDrift } from '../core/profile-sync-drift.js';
 import { CLI_NAME } from '../core/branding.js';
+import { buildGeneratedInstructionDriftReport } from '../core/shared/tool-detection.js';
 import { resolveLegacySpecLiveRoot } from '../core/sdd/services/legacy-capability.service.js';
-import { resolveRedisBoundaryConfig } from '../core/sdd/coordination/index.js';
+import { buildRedisOperationalReport, deleteKeysByPrefix, RedisClientFactory, resolveRedisBoundaryConfig, runRedisBenchmark, } from '../core/sdd/coordination/index.js';
+import { buildCodesddStorageBoundaryReport } from '../core/sdd/runtime-boundary-contract.js';
+import { buildEnterpriseProvisioningPolicyReport } from '../core/sdd/enterprise-provisioning-policy.js';
 import { buildDeepAgentsOperationalPreflight, createDeepAgentsPolicySnapshot, } from '../core/sdd/deepagents/policy.js';
 import { detectShell } from '../utils/shell-detection.js';
 import { ZshInstaller } from '../core/completions/installers/zsh-installer.js';
@@ -70,6 +73,10 @@ function buildCodesddEnvTemplate() {
         'export CODESDD_DEEPAGENTS_RUNTIME="${CODESDD_DEEPAGENTS_RUNTIME:-disabled}"',
         'export CODESDD_AGENT_NETWORK_POLICY="${CODESDD_AGENT_NETWORK_POLICY:-disabled}"',
         'export CODESDD_DEEPAGENTS_PROVIDER_SMOKE="${CODESDD_DEEPAGENTS_PROVIDER_SMOKE:-0}"',
+        'export CODESDD_REDIS_ENABLED="${CODESDD_REDIS_ENABLED:-false}"',
+        'export CODESDD_REDIS_NAMESPACE="${CODESDD_REDIS_NAMESPACE:-codesdd}"',
+        '# export CODESDD_REDIS_URL="redis://localhost:6379"',
+        '# export CODESDD_REDIS_FALLBACK="filesystem"',
         '# Optional live-provider launcher references. Keep values in your shell,',
         '# password manager, CI secret store, or another untracked launcher context.',
         '# export CODESDD_DEEPAGENTS_ENABLED=true',
@@ -255,11 +262,18 @@ export function registerConfigCommand(program) {
         .command('doctor')
         .description('Run operational readiness checks for DeepAgents/Azure, cache, and Redis boundary')
         .option('--json', 'Output as JSON')
-        .action((options) => {
+        .action(async (options) => {
         const snapshot = createDeepAgentsPolicySnapshot(process.env);
         const preflight = buildDeepAgentsOperationalPreflight(snapshot, process.env);
-        const redisBoundary = resolveRedisBoundaryConfig(process.env);
+        const redisReport = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        const globalConfig = getGlobalConfig();
         const cacheTiers = getGlobalCacheTierDirs();
+        const storageBoundary = buildCodesddStorageBoundaryReport(process.cwd());
+        const generatedInstructions = buildGeneratedInstructionDriftReport(process.cwd());
+        const enterpriseProvisioning = buildEnterpriseProvisioningPolicyReport(globalConfig, process.env);
         const report = {
             schema_version: 1,
             global_config_path: getGlobalConfigPath(),
@@ -267,11 +281,20 @@ export function registerConfigCommand(program) {
                 root: getGlobalCacheDir(),
                 tiers: Object.keys(cacheTiers),
             },
+            storage_boundary: storageBoundary,
+            generated_instructions: generatedInstructions,
             redis: {
-                requested: redisBoundary.requested,
-                namespace: redisBoundary.namespace,
-                status: redisBoundary.requested ? 'requested-unavailable' : 'disabled',
+                requested: redisReport.requested,
+                namespace: redisReport.namespace,
+                status: redisReport.status,
+                fallback: redisReport.fallback,
+                redacted_url: redisReport.redacted_url,
+                latency_ms: redisReport.latency_ms,
+                reason: redisReport.reason,
+                validation_errors: redisReport.validation_errors,
+                warnings: redisReport.warnings,
             },
+            enterprise_provisioning: enterpriseProvisioning,
             deepagents: preflight,
         };
         if (options.json) {
@@ -281,14 +304,170 @@ export function registerConfigCommand(program) {
             console.log(`Global config: ${report.global_config_path}`);
             console.log(`Cache root: ${report.cache.root}`);
             console.log(`Cache tiers: ${report.cache.tiers.join(', ')}`);
-            console.log(`Redis: ${report.redis.status} (namespace=${report.redis.namespace})`);
+            console.log(`Project state: ${report.storage_boundary.project_state_dir}`);
+            console.log(`Global runtime: ${report.storage_boundary.global_runtime_dir}`);
+            console.log(`Generated instructions: ${generatedInstructions.status} (checked=${generatedInstructions.checked_count}, stale=${generatedInstructions.stale_count})`);
+            for (const warning of generatedInstructions.warnings) {
+                console.log(`- ${warning}`);
+            }
+            for (const staleFile of generatedInstructions.stale_files.slice(0, 10)) {
+                console.log(`- stale ${staleFile.kind}: ${staleFile.path}`);
+            }
+            console.log(`Redis: ${report.redis.status} (namespace=${report.redis.namespace}, fallback=${report.redis.fallback})`);
+            if (report.redis.redacted_url) {
+                console.log(`Redis URL: ${report.redis.redacted_url}`);
+            }
+            if (report.redis.latency_ms !== undefined) {
+                console.log(`Redis latency: ${report.redis.latency_ms}ms`);
+            }
+            console.log(`Redis reason: ${report.redis.reason}`);
+            for (const warning of report.redis.warnings) {
+                console.log(`- ${warning}`);
+            }
+            for (const error of report.redis.validation_errors) {
+                console.log(`- ${error}`);
+            }
+            const enterpriseRequestedMode = enterpriseProvisioning.requested_mode ?? enterpriseProvisioning.mode;
+            const enterpriseEffectiveMode = enterpriseProvisioning.effective_mode ?? (enterpriseProvisioning.requested ? 'enterprise' : 'local');
+            const localModeExceptionAccepted = enterpriseProvisioning.local_mode_exception_accepted ?? !enterpriseProvisioning.requested;
+            console.log(`Enterprise provisioning: ${enterpriseProvisioning.status}`);
+            console.log(`Enterprise requested mode: ${enterpriseRequestedMode}`);
+            console.log(`Enterprise effective mode: ${enterpriseEffectiveMode}`);
+            console.log(`Enterprise local-mode exception accepted: ${localModeExceptionAccepted ? 'yes' : 'no'}`);
+            console.log(`Enterprise provisioning reason: ${enterpriseProvisioning.reason}`);
+            console.log(`Enterprise provisioning next action: ${enterpriseProvisioning.next_action}`);
+            for (const error of enterpriseProvisioning.validation_errors) {
+                console.log(`- ${error}`);
+            }
             console.log(`DeepAgents preflight: ${preflight.status}`);
             for (const reason of preflight.reasons) {
                 console.log(`- ${reason}`);
             }
         }
-        if (preflight.status === 'blocked') {
+        if (preflight.status === 'blocked' || redisReport.status === 'blocked' || enterpriseProvisioning.status === 'blocked') {
+            process.exitCode = 1;
+        }
+    });
+    const redisCmd = configCmd
+        .command('redis')
+        .description('Inspect and operate the optional Redis runtime backend');
+    redisCmd
+        .command('status')
+        .description('Show Redis runtime status')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+            return;
+        }
+        console.log(`Redis: ${report.status}`);
+        console.log(`Namespace: ${report.namespace}`);
+        console.log(`Fallback: ${report.fallback}`);
+        if (report.redacted_url)
+            console.log(`URL: ${report.redacted_url}`);
+        if (report.latency_ms !== undefined)
+            console.log(`Latency: ${report.latency_ms}ms`);
+        console.log(`Reason: ${report.reason}`);
+        if (report.status === 'blocked')
+            process.exitCode = 1;
+    });
+    redisCmd
+        .command('ping')
+        .description('Ping Redis using the effective CodeSDD configuration')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Redis ping: ${report.status}`);
+            if (report.latency_ms !== undefined)
+                console.log(`Latency: ${report.latency_ms}ms`);
+            console.log(report.reason);
+        }
+        if (report.status !== 'ready')
             process.exitCode = 1;
+    });
+    redisCmd
+        .command('bench')
+        .description('Run a short redacted Redis latency benchmark')
+        .option('--json', 'Output as JSON')
+        .option('--iterations <n>', 'Number of benchmark iterations')
+        .action(async (options) => {
+        const iterations = options.iterations ? Number.parseInt(options.iterations, 10) : undefined;
+        const report = await runRedisBenchmark({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+            iterations,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`Redis benchmark: ${report.status}`);
+            console.log(`Namespace: ${report.namespace}`);
+            console.log(`Iterations: ${report.iterations}`);
+            if (report.p50_ms !== undefined)
+                console.log(`p50: ${report.p50_ms}ms`);
+            if (report.p95_ms !== undefined)
+                console.log(`p95: ${report.p95_ms}ms`);
+            console.log(`Reason: ${report.reason}`);
+        }
+        if (report.status !== 'ready')
+            process.exitCode = 1;
+    });
+    redisCmd
+        .command('flush-namespace')
+        .description('Delete only keys under the effective CodeSDD Redis namespace')
+        .option('--json', 'Output as JSON')
+        .option('-y, --yes', 'Confirm namespace-scoped deletion')
+        .action(async (options) => {
+        const config = resolveRedisBoundaryConfig(process.env, getGlobalConfig());
+        if (!options.yes) {
+            console.error('Error: --yes is required to flush the CodeSDD Redis namespace.');
+            process.exitCode = 1;
+            return;
+        }
+        const report = await buildRedisOperationalReport({
+            env: process.env,
+            globalConfig: getGlobalConfig(),
+        });
+        if (report.status !== 'ready') {
+            if (options.json) {
+                console.log(JSON.stringify({ ...report, deleted_keys: 0 }, null, 2));
+            }
+            else {
+                console.log(`Redis namespace flush skipped: ${report.reason}`);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const factory = new RedisClientFactory(config);
+        try {
+            const deleted = await deleteKeysByPrefix(factory, `${config.namespace}:`);
+            const payload = {
+                schema_version: 1,
+                namespace: config.namespace,
+                deleted_keys: deleted,
+                status: 'ok',
+            };
+            if (options.json) {
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                console.log(`Deleted ${deleted} Redis key(s) under namespace ${config.namespace}.`);
+            }
+        }
+        finally {
+            await factory.close();
         }
     });
     // config list
@@ -331,11 +510,19 @@ export function registerConfigCommand(program) {
             console.log(`\nCache settings:`);
             console.log(`  root: ${getGlobalCacheDir()}`);
             console.log(`  tiers: ${Object.keys(cacheTiers).join(', ')}`);
-            const redisBoundary = resolveRedisBoundaryConfig(process.env);
-            const redisStatus = redisBoundary.requested ? 'requested-unavailable (filesystem-first fallback)' : 'disabled';
+            const redisBoundary = resolveRedisBoundaryConfig(process.env, config);
+            const redisStatus = redisBoundary.validationErrors.length > 0
+                ? 'blocked'
+                : redisBoundary.requested
+                    ? 'requested-unavailable or ready after ping'
+                    : 'disabled';
             console.log(`\nRedis boundary:`);
             console.log(`  status: ${redisStatus}`);
             console.log(`  namespace: ${redisBoundary.namespace}`);
+            console.log(`  fallback: ${redisBoundary.fallback}`);
+            if (redisBoundary.redactedUrl) {
+                console.log(`  url: ${redisBoundary.redactedUrl}`);
+            }
         }
     });
     // config get