@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/cli-command-quality.js

@@ -0,0 +1,171 @@
+const OWNER = 'CodeSDD maintainers';
+const REVIEW_DEADLINE = '2026-11-09';
+export const UNIVERSAL_SPAWNED_HELP_SMOKE_REF = 'test/cli-e2e/all-commands-smoke.test.ts';
+function withUniversalSpawnedHelpSmoke(validationRefs) {
+    return Array.from(new Set([UNIVERSAL_SPAWNED_HELP_SMOKE_REF, ...validationRefs]));
+}
+function entry(path, evidenceMode, rationale, validationRefs, options = {}) {
+    return {
+        path,
+        evidence_mode: evidenceMode,
+        owner: OWNER,
+        rationale,
+        validation_refs: withUniversalSpawnedHelpSmoke(validationRefs),
+        interactive: options.interactive ?? false,
+        exception: options.exception,
+    };
+}
+function entries(paths, evidenceMode, rationale, validationRefs) {
+    return paths.map((path) => entry(path, evidenceMode, rationale, validationRefs));
+}
+function exceptionEntry(path, reason, acceptedRisk, compensatingControl, validationRefs) {
+    return entry(path, 'exception', 'Interactive, deprecated, or local-environment-sensitive command that needs compensating contract evidence.', validationRefs, {
+        interactive: true,
+        exception: {
+            reason,
+            accepted_risk: acceptedRisk,
+            compensating_control: compensatingControl,
+            review_deadline: REVIEW_DEADLINE,
+        },
+    });
+}
+export const CLI_COMMAND_QUALITY_MATRIX = [
+    ...entries([
+        'init',
+        'reload',
+        'install',
+        'validate',
+        'sdd init',
+        'sdd insight',
+        'sdd debate',
+        'sdd decide',
+        'sdd breakdown',
+        'sdd aprovar',
+        'sdd start',
+        'sdd context',
+        'sdd frontend-impact',
+        'sdd finalize',
+        'sdd init-context',
+        'sdd rebuild',
+        'sdd metrics',
+        'sdd dedup',
+        'sdd lint feature',
+    ], 'spawned_e2e', 'Critical user-facing lifecycle or package-entrypoint command with spawned CLI coverage.', [
+        'test/helpers/run-cli.test.ts',
+        'test/cli-e2e/basic.test.ts',
+        'test/cli-e2e/critical-smoke.test.ts',
+        'test/e2e/full-lifecycle.test.ts',
+    ]),
+    ...entries([
+        'archive',
+        'change list',
+        'change show',
+        'change validate',
+        'completion generate',
+        'completion install',
+        'completion uninstall',
+        'config doctor',
+        'config get',
+        'config init',
+        'config list',
+        'config path',
+        'config reset',
+        'config set',
+        'config unset',
+        'feedback',
+        'list',
+        'new change',
+        'schema fork',
+        'schema init',
+        'schema validate',
+        'schema which',
+        'schemas',
+        'show',
+        'spec list',
+        'spec show',
+        'spec validate',
+        'status',
+        'templates',
+        'update',
+    ], 'in_process', 'Command behavior is covered by focused command or core tests, with universal spawned help smoke covering the bin entrypoint.', ['test/commands', 'test/core']),
+    ...entries([
+        '__complete',
+        'config profile',
+        'instructions',
+        'sdd audit',
+        'sdd check',
+        'sdd diagnose',
+        'sdd agent run',
+        'sdd fgap add',
+        'sdd fgap done',
+        'sdd fingerprint',
+        'sdd import-legacy-spec',
+        'sdd ingest-deposito',
+        'sdd mcp-call',
+        'sdd mcp-manifest',
+        'sdd migrate',
+        'sdd migrate-workspace',
+        'sdd next',
+        'sdd onboard',
+        'sdd backlog project',
+        'sdd plugin devtrack-api scaffold-dry-run',
+        'sdd plugin inspect',
+        'sdd plugin plan',
+        'sdd sanitize rollback',
+        'sdd scan-naming',
+        'sdd skills bundles',
+        'sdd skills suggest',
+        'sdd skills sync',
+        'sdd skills usar',
+        'sdd upgrade-to-codesdd',
+    ], 'contract', 'Command has registration, service, or workflow contract coverage, with universal spawned help smoke covering the bin entrypoint.', ['test/commands/sdd-command.test.ts', 'test/core/sdd-operations.test.ts']),
+    exceptionEntry('experimental', 'Hidden deprecated alias retained only for backwards compatibility.', 'A packaging regression in the hidden alias may not be caught by critical-path spawned smoke tests.', 'Registration inventory keeps the alias visible, and init command coverage protects the underlying implementation.', ['src/cli/index.ts', 'test/cli-e2e/basic.test.ts']),
+    exceptionEntry('view', 'Interactive dashboard command depends on terminal UI behavior and is unsuitable for deterministic spawned CI coverage.', 'Terminal rendering regressions may require manual or future TUI-specific verification.', 'Keep command registration visible and cover the underlying view module with focused tests.', ['src/core/view.ts', 'test/core/view.test.ts']),
+    exceptionEntry('config edit', 'Launches the user editor and depends on local EDITOR behavior.', 'Editor launch behavior can vary by machine and shell configuration.', 'Config schema read/write operations are covered by non-editor config command tests.', ['test/commands/config.test.ts', 'test/core/config-schema.test.ts']),
+];
+export function commandQualityMatrixByPath(matrix = CLI_COMMAND_QUALITY_MATRIX) {
+    return new Map(matrix.map((item) => [item.path, item]));
+}
+export function validateCliCommandQualityMatrix(registeredLeafCommandPaths, matrix = CLI_COMMAND_QUALITY_MATRIX) {
+    const registered = new Set(registeredLeafCommandPaths);
+    const matrixPaths = matrix.map((item) => item.path);
+    const matrixPathSet = new Set(matrixPaths);
+    const duplicatePaths = matrixPaths
+        .filter((path, index) => matrixPaths.indexOf(path) !== index)
+        .sort();
+    const invalidEntries = matrix.flatMap((item) => {
+        const errors = [];
+        if (!item.path.trim())
+            errors.push('path is required');
+        if (!item.owner.trim())
+            errors.push('owner is required');
+        if (!item.rationale.trim())
+            errors.push('rationale is required');
+        if (item.validation_refs.length === 0)
+            errors.push('validation_refs must not be empty');
+        if (item.evidence_mode === 'exception') {
+            if (!item.exception) {
+                errors.push('exception details are required');
+            }
+            else {
+                if (!item.exception.reason.trim())
+                    errors.push('exception.reason is required');
+                if (!item.exception.accepted_risk.trim())
+                    errors.push('exception.accepted_risk is required');
+                if (!item.exception.compensating_control.trim()) {
+                    errors.push('exception.compensating_control is required');
+                }
+                if (!item.exception.review_deadline.trim())
+                    errors.push('exception.review_deadline is required');
+            }
+        }
+        return errors.map((error) => `${item.path}: ${error}`);
+    });
+    return {
+        missing: registeredLeafCommandPaths.filter((path) => !matrixPathSet.has(path)).sort(),
+        extra: matrixPaths.filter((path) => !registered.has(path)).sort(),
+        duplicate_paths: Array.from(new Set(duplicatePaths)),
+        invalid_entries: invalidEntries.sort(),
+    };
+}
+//# sourceMappingURL=cli-command-quality.js.map

package/dist/core/command-generation/adapters/costrict.d.ts

@@ -6,7 +6,7 @@
 import type { ToolCommandAdapter } from '../types.js';
 /**
  * CoStrict adapter for command generation.
- * File path: .cospec/openspec/commands/opsx-<id>.md
+ * File path: .cospec/legacy-spec/commands/opsx-<id>.md
  * Frontmatter: description, argument-hint
  */
 export declare const costrictAdapter: ToolCommandAdapter;

package/dist/core/command-generation/adapters/costrict.js

@@ -6,13 +6,13 @@
 import path from 'path';
 /**
  * CoStrict adapter for command generation.
- * File path: .cospec/openspec/commands/opsx-<id>.md
+ * File path: .cospec/legacy-spec/commands/opsx-<id>.md
  * Frontmatter: description, argument-hint
  */
 export const costrictAdapter = {
     toolId: 'costrict',
     getFilePath(commandId) {
-        return path.join('.cospec', 'openspec', 'commands', `opsx-${commandId}.md`);
+        return path.join('.cospec', 'codesdd', 'commands', `opsx-${commandId}.md`);
     },
     formatFile(content) {
         return `---

package/dist/core/command-generation/types.d.ts

@@ -11,7 +11,7 @@
 export interface CommandContent {
     /** Command identifier (e.g., 'explore', 'apply', 'new') */
     id: string;
-    /** Human-readable name (e.g., 'OpenSpec Explore') */
+    /** Human-readable name (e.g., 'CodeSDD Explore') */
     name: string;
     /** Brief description of command purpose */
     description: string;

package/dist/core/completions/command-registry.d.ts

@@ -1,6 +1,6 @@
 import { CommandDefinition } from './types.js';
 /**
- * Registry of all OpenSpec CLI commands with their flags and metadata.
+ * Registry of all visible CodeSDD CLI commands with their flags and metadata.
  * This registry is used to generate shell completion scripts.
  */
 export declare const COMMAND_REGISTRY: CommandDefinition[];

package/dist/core/completions/command-registry.js

@@ -1,3 +1,4 @@
+import { CLI_COMMAND_MATRIX } from '../cli/command-matrix.js';
 /**
  * Common flags used across multiple commands
  */
@@ -26,13 +27,13 @@ const COMMON_FLAGS = {
     },
 };
 /**
- * Registry of all OpenSpec CLI commands with their flags and metadata.
- * This registry is used to generate shell completion scripts.
+ * Curated command metadata overrides for commands that need richer flag or
+ * positional completion than the command matrix can provide by itself.
  */
-export const COMMAND_REGISTRY = [
+const COMMAND_METADATA_OVERRIDES = [
     {
         name: 'init',
-        description: 'Initialize OpenSpec in your project',
+        description: 'Initialize CodeSDD in your project',
         acceptsPositional: true,
         positionalType: 'path',
         flags: [
@@ -43,12 +44,60 @@ export const COMMAND_REGISTRY = [
             },
         ],
     },
+    {
+        name: 'reload',
+        description: 'Reload CodeSDD project files using the installed CLI version',
+        acceptsPositional: true,
+        positionalType: 'path',
+        flags: [
+            {
+                name: 'tools',
+                description: 'Configure AI tools non-interactively (e.g., "all", "none", or comma-separated tool IDs)',
+                takesValue: true,
+            },
+            {
+                name: 'force',
+                description: 'Auto-cleanup legacy files without prompting',
+            },
+            {
+                name: 'profile',
+                description: 'Override global config profile (core or custom)',
+                takesValue: true,
+            },
+            {
+                name: 'lang',
+                description: 'SDD language: pt-BR|en-US',
+                takesValue: true,
+                values: ['pt-BR', 'en-US'],
+            },
+            {
+                name: 'layout',
+                description: 'SDD folder layout: en-US|legacy|pt-BR',
+                takesValue: true,
+                values: ['en-US', 'legacy', 'pt-BR'],
+            },
+            {
+                name: 'no-frontend',
+                description: 'Disable frontend module in the SDD bootstrap',
+            },
+            {
+                name: 'no-render',
+                description: 'Do not render Markdown views after reload',
+            },
+            COMMON_FLAGS.json,
+        ],
+    },
     {
         name: 'update',
-        description: 'Update OpenSpec instruction files',
+        description: 'Update CodeSDD instruction files',
         acceptsPositional: true,
         positionalType: 'path',
-        flags: [],
+        flags: [
+            {
+                name: 'force',
+                description: 'Force update even when tools are up to date',
+            },
+        ],
     },
     {
         name: 'list',
@@ -62,6 +111,13 @@ export const COMMAND_REGISTRY = [
                 name: 'changes',
                 description: 'List changes explicitly (default)',
             },
+            {
+                name: 'sort',
+                description: 'Sort order: recent (default) or name',
+                takesValue: true,
+                values: ['recent', 'name'],
+            },
+            COMMON_FLAGS.json,
         ],
     },
     {
@@ -92,7 +148,7 @@ export const COMMAND_REGISTRY = [
             COMMON_FLAGS.jsonValidation,
             {
                 name: 'concurrency',
-                description: 'Max concurrent validations (defaults to env OPENSPEC_CONCURRENCY or 6)',
+                description: 'Max concurrent validations (defaults to env CODESDD_CONCURRENCY or 6)',
                 takesValue: true,
             },
             COMMON_FLAGS.noInteractive,
@@ -154,7 +210,7 @@ export const COMMAND_REGISTRY = [
     },
     {
         name: 'feedback',
-        description: 'Submit feedback about OpenSpec',
+        description: 'Submit feedback about CodeSDD',
         acceptsPositional: true,
         flags: [
             {
@@ -166,7 +222,7 @@ export const COMMAND_REGISTRY = [
     },
     {
         name: 'change',
-        description: 'Manage OpenSpec change proposals (deprecated)',
+        description: 'Manage legacy change proposals (deprecated)',
         flags: [],
         subcommands: [
             {
@@ -213,7 +269,7 @@ export const COMMAND_REGISTRY = [
     },
     {
         name: 'spec',
-        description: 'Manage OpenSpec specifications',
+        description: 'Manage specifications',
         flags: [],
         subcommands: [
             {
@@ -266,7 +322,7 @@ export const COMMAND_REGISTRY = [
     },
     {
         name: 'completion',
-        description: 'Manage shell completions for OpenSpec CLI',
+        description: 'Manage shell completions for CodeSDD CLI',
         flags: [],
         subcommands: [
             {
@@ -305,7 +361,7 @@ export const COMMAND_REGISTRY = [
     },
     {
         name: 'config',
-        description: 'View and modify global OpenSpec configuration',
+        description: 'View and modify global CodeSDD configuration',
         flags: [
             {
                 name: 'scope',
@@ -320,6 +376,20 @@ export const COMMAND_REGISTRY = [
                 description: 'Show config file location',
                 flags: [],
             },
+            {
+                name: 'init',
+                description: 'Initialize ~/.codesdd runtime files and idempotent shell integration',
+                flags: [
+                    COMMON_FLAGS.json,
+                ],
+            },
+            {
+                name: 'doctor',
+                description: 'Run operational readiness checks for DeepAgents/Azure, cache, and Redis boundary',
+                flags: [
+                    COMMON_FLAGS.json,
+                ],
+            },
             {
                 name: 'list',
                 description: 'Show all current settings',
@@ -458,4 +528,77 @@ export const COMMAND_REGISTRY = [
         ],
     },
 ];
+const HIDDEN_OR_INTERNAL_COMMAND_PATHS = new Set([
+    'experimental',
+    '__complete',
+]);
+function cloneCommandDefinition(command) {
+    return {
+        ...command,
+        flags: command.flags.map((flag) => ({ ...flag, values: flag.values ? [...flag.values] : undefined })),
+        subcommands: command.subcommands?.map(cloneCommandDefinition),
+    };
+}
+function collectLeafCommandPaths(commands, prefix = []) {
+    const paths = new Set();
+    for (const command of commands) {
+        const nextPrefix = [...prefix, command.name];
+        if (command.subcommands && command.subcommands.length > 0) {
+            for (const childPath of collectLeafCommandPaths(command.subcommands, nextPrefix)) {
+                paths.add(childPath);
+            }
+        }
+        else {
+            paths.add(nextPrefix.join(':'));
+        }
+    }
+    return paths;
+}
+function findOrCreateCommand(commands, name, description) {
+    const existing = commands.find((command) => command.name === name);
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        name,
+        description,
+        flags: [],
+    };
+    commands.push(created);
+    return created;
+}
+function humanizeCommandPath(commandPath) {
+    return `Run ${commandPath.split(':').join(' ')} command`;
+}
+function addCommandPath(commands, commandPath) {
+    const segments = commandPath.split(':');
+    let currentCommands = commands;
+    segments.forEach((segment, index) => {
+        const isLeaf = index === segments.length - 1;
+        const definition = findOrCreateCommand(currentCommands, segment, isLeaf ? humanizeCommandPath(commandPath) : `Manage ${segments.slice(0, index + 1).join(' ')} commands`);
+        if (!isLeaf) {
+            definition.subcommands ??= [];
+            currentCommands = definition.subcommands;
+        }
+    });
+}
+function buildCompleteCommandRegistry(baseRegistry) {
+    const registry = baseRegistry.map(cloneCommandDefinition);
+    const existingLeafPaths = collectLeafCommandPaths(registry);
+    for (const entry of CLI_COMMAND_MATRIX) {
+        if (HIDDEN_OR_INTERNAL_COMMAND_PATHS.has(entry.commandPath)) {
+            continue;
+        }
+        if (!existingLeafPaths.has(entry.commandPath)) {
+            addCommandPath(registry, entry.commandPath);
+            existingLeafPaths.add(entry.commandPath);
+        }
+    }
+    return registry;
+}
+/**
+ * Registry of all visible CodeSDD CLI commands with their flags and metadata.
+ * This registry is used to generate shell completion scripts.
+ */
+export const COMMAND_REGISTRY = buildCompleteCommandRegistry(COMMAND_METADATA_OVERRIDES);
 //# sourceMappingURL=command-registry.js.map

package/dist/core/completions/completion-provider.d.ts

@@ -1,5 +1,5 @@
 /**
- * Provides dynamic completion suggestions for OpenSpec items (changes and specs).
+ * Provides dynamic completion suggestions for CodeSDD items (changes and specs).
  * Implements a 2-second cache to avoid excessive file system operations during
  * tab completion.
  */
@@ -7,8 +7,10 @@ export declare class CompletionProvider {
     private readonly cacheTTLMs;
     private readonly projectRoot;
     private readonly cacheTTL;
+    private readonly projectFingerprint;
     private changeCache;
     private specCache;
+    private schemaCache;
     /**
      * Creates a new completion provider
      *
@@ -37,6 +39,12 @@ export declare class CompletionProvider {
         changeIds: string[];
         specIds: string[];
     }>;
+    /**
+     * Get all workflow schema names for completion
+     *
+     * @returns Array of schema names
+     */
+    getSchemaNames(): Promise<string[]>;
     /**
      * Clear all cached data
      */
@@ -47,6 +55,7 @@ export declare class CompletionProvider {
      * @returns Cache status information
      */
     getCacheStats(): {
+        projectFingerprint: string;
         changeCache: {
             valid: boolean;
             age?: number;
@@ -55,6 +64,10 @@ export declare class CompletionProvider {
             valid: boolean;
             age?: number;
         };
+        schemaCache: {
+            valid: boolean;
+            age?: number;
+        };
     };
 }
 //# sourceMappingURL=completion-provider.d.ts.map

package/dist/core/completions/completion-provider.js

@@ -1,6 +1,8 @@
 import { getActiveChangeIds, getSpecIds } from '../../utils/item-discovery.js';
+import { listSchemas } from '../artifact-graph/index.js';
+import { createProjectFingerprint } from '../global-config.js';
 /**
- * Provides dynamic completion suggestions for OpenSpec items (changes and specs).
+ * Provides dynamic completion suggestions for CodeSDD items (changes and specs).
  * Implements a 2-second cache to avoid excessive file system operations during
  * tab completion.
  */
@@ -8,8 +10,10 @@ export class CompletionProvider {
     cacheTTLMs;
     projectRoot;
     cacheTTL;
+    projectFingerprint;
     changeCache = null;
     specCache = null;
+    schemaCache = null;
     /**
      * Creates a new completion provider
      *
@@ -20,6 +24,7 @@ export class CompletionProvider {
         this.cacheTTLMs = cacheTTLMs;
         this.projectRoot = projectRoot;
         this.cacheTTL = cacheTTLMs;
+        this.projectFingerprint = createProjectFingerprint(projectRoot);
     }
     /**
      * Get all active change IDs for completion
@@ -73,12 +78,30 @@ export class CompletionProvider {
         ]);
         return { changeIds, specIds };
     }
+    /**
+     * Get all workflow schema names for completion
+     *
+     * @returns Array of schema names
+     */
+    async getSchemaNames() {
+        const now = Date.now();
+        if (this.schemaCache && now - this.schemaCache.timestamp < this.cacheTTL) {
+            return this.schemaCache.data;
+        }
+        const schemaNames = listSchemas(this.projectRoot);
+        this.schemaCache = {
+            data: schemaNames,
+            timestamp: now,
+        };
+        return schemaNames;
+    }
     /**
      * Clear all cached data
      */
     clearCache() {
         this.changeCache = null;
         this.specCache = null;
+        this.schemaCache = null;
     }
     /**
      * Get cache statistics for debugging
@@ -88,6 +111,7 @@ export class CompletionProvider {
     getCacheStats() {
         const now = Date.now();
         return {
+            projectFingerprint: this.projectFingerprint,
             changeCache: {
                 valid: this.changeCache !== null && now - this.changeCache.timestamp < this.cacheTTL,
                 age: this.changeCache ? now - this.changeCache.timestamp : undefined,
@@ -96,6 +120,10 @@ export class CompletionProvider {
                 valid: this.specCache !== null && now - this.specCache.timestamp < this.cacheTTL,
                 age: this.specCache ? now - this.specCache.timestamp : undefined,
             },
+            schemaCache: {
+                valid: this.schemaCache !== null && now - this.schemaCache.timestamp < this.cacheTTL,
+                age: this.schemaCache ? now - this.schemaCache.timestamp : undefined,
+            },
         };
     }
 }

package/dist/core/completions/generators/bash-generator.d.ts

@@ -1,6 +1,6 @@
 import { CompletionGenerator, CommandDefinition } from '../types.js';
 /**
- * Generates Bash completion scripts for the OpenSpec CLI.
+ * Generates Bash completion scripts for the CodeSDD CLI.
  * Follows Bash completion conventions using complete builtin and COMPREPLY array.
  */
 export declare class BashGenerator implements CompletionGenerator {