@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

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',
@@ -379,6 +449,51 @@ export const COMMAND_REGISTRY = [
                 description: 'Configure workflow profile (interactive picker or preset shortcut)',
                 flags: [],
             },
+            {
+                name: 'redis',
+                description: 'Inspect and operate the optional Redis runtime backend',
+                flags: [],
+                subcommands: [
+                    {
+                        name: 'status',
+                        description: 'Show Redis runtime status',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'ping',
+                        description: 'Ping Redis using the effective CodeSDD configuration',
+                        flags: [
+                            COMMON_FLAGS.json,
+                        ],
+                    },
+                    {
+                        name: 'bench',
+                        description: 'Run a short redacted Redis latency benchmark',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'iterations',
+                                description: 'Number of benchmark iterations',
+                                takesValue: true,
+                            },
+                        ],
+                    },
+                    {
+                        name: 'flush-namespace',
+                        description: 'Delete only keys under the effective CodeSDD Redis namespace',
+                        flags: [
+                            COMMON_FLAGS.json,
+                            {
+                                name: 'yes',
+                                short: 'y',
+                                description: 'Confirm namespace-scoped deletion',
+                            },
+                        ],
+                    },
+                ],
+            },
         ],
     },
     {
@@ -458,4 +573,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 {

package/dist/core/completions/generators/bash-generator.js

@@ -1,6 +1,6 @@
 import { BASH_DYNAMIC_HELPERS } from '../templates/bash-templates.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 class BashGenerator {
@@ -25,10 +25,10 @@ export class BashGenerator {
         // Dynamic completion helpers from template
         const helpers = BASH_DYNAMIC_HELPERS;
         // Assemble final script with template literal
-        return `# Bash completion script for OpenSpec CLI
+        return `# Bash completion script for CodeSDD CLI
 # Auto-generated - do not edit manually
 
-_openspec_completion() {
+_codesdd_completion() {
   local cur prev words cword
 
   # Use _init_completion if available (from bash-completion package)
@@ -47,7 +47,6 @@ _openspec_completion() {
   fi
 
   local cmd="\${words[1]}"
-  local subcmd="\${words[2]}"
 
   # Top-level commands
   if [[ $cword -eq 1 ]]; then
@@ -65,13 +64,13 @@ ${commandCases}
 }
 
 ${helpers}
-complete -F _openspec_completion openspec
+complete -F _codesdd_completion codesdd
 `;
     }
     /**
      * Generate completion case logic for a command
      */
-    generateCommandCase(cmd, indent) {
+    generateCommandCase(cmd, indent, depth = 2) {
         const lines = [];
         // Handle subcommands
         if (cmd.subcommands && cmd.subcommands.length > 0) {
@@ -91,16 +90,22 @@ complete -F _openspec_completion openspec
                 lines.push(`${indent}fi`);
                 lines.push('');
             }
-            lines.push(`${indent}if [[ $cword -eq 2 ]]; then`);
+            lines.push(`${indent}if [[ $cword -eq ${depth} ]]; then`);
             lines.push(`${indent}  local subcommands="` + cmd.subcommands.map(s => this.escapeCommandName(s.name)).join(' ') + '"');
             lines.push(`${indent}  COMPREPLY=($(compgen -W "$subcommands" -- "$cur"))`);
             lines.push(`${indent}  return 0`);
             lines.push(`${indent}fi`);
             lines.push('');
-            lines.push(`${indent}case "$subcmd" in`);
+            lines.push(`${indent}local subcmd_${depth}="\${words[${depth}]}"`);
+            lines.push(`${indent}case "$subcmd_${depth}" in`);
             for (const subcmd of cmd.subcommands) {
                 lines.push(`${indent}  ${subcmd.name})`);
-                lines.push(...this.generateArgumentCompletion(subcmd, indent + '    '));
+                if (subcmd.subcommands && subcmd.subcommands.length > 0) {
+                    lines.push(...this.generateCommandCase(subcmd, indent + '    ', depth + 1));
+                }
+                else {
+                    lines.push(...this.generateArgumentCompletion(subcmd, indent + '    '));
+                }
                 lines.push(`${indent}    ;;`);
             }
             lines.push(`${indent}esac`);
@@ -145,13 +150,13 @@ complete -F _openspec_completion openspec
         const lines = [];
         switch (positionalType) {
             case 'change-id':
-                lines.push(`${indent}_openspec_complete_changes`);
+                lines.push(`${indent}_codesdd_complete_changes`);
                 break;
             case 'spec-id':
-                lines.push(`${indent}_openspec_complete_specs`);
+                lines.push(`${indent}_codesdd_complete_specs`);
                 break;
             case 'change-or-spec-id':
-                lines.push(`${indent}_openspec_complete_items`);
+                lines.push(`${indent}_codesdd_complete_items`);
                 break;
             case 'shell':
                 lines.push(`${indent}local shells="zsh bash fish powershell"`);
@@ -160,6 +165,9 @@ complete -F _openspec_completion openspec
             case 'path':
                 lines.push(`${indent}COMPREPLY=($(compgen -f -- "$cur"))`);
                 break;
+            case 'schema-name':
+                lines.push(`${indent}_codesdd_complete_schemas`);
+                break;
         }
         return lines;
     }

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

@@ -1,6 +1,6 @@
 import { CompletionGenerator, CommandDefinition } from '../types.js';
 /**
- * Generates Fish completion scripts for the OpenSpec CLI.
+ * Generates Fish completion scripts for the CodeSDD CLI.
  * Follows Fish completion conventions using the complete command.
  */
 export declare class FishGenerator implements CompletionGenerator {
@@ -16,6 +16,14 @@ export declare class FishGenerator implements CompletionGenerator {
      * Generate completions for a specific command
      */
     private generateCommandCompletions;
+    /**
+     * Generate completions for a command path at any depth.
+     */
+    private generateNodeCompletions;
+    /**
+     * Generate a Fish condition that checks every command segment in a path.
+     */
+    private generatePathCondition;
     /**
      * Generate flag completion
      */