@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/global-config.js

@@ -1,48 +1,310 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { createHash } from 'node:crypto';
 // Constants
-export const GLOBAL_CONFIG_DIR_NAME = 'openspec';
-export const GLOBAL_CONFIG_FILE_NAME = 'config.json';
-export const GLOBAL_DATA_DIR_NAME = 'openspec';
+export const GLOBAL_CONFIG_DIR_NAME = '.codesdd';
+export const GLOBAL_CONFIG_FILE_NAME = 'config.toml';
+export const GLOBAL_DATA_DIR_NAME = 'codesdd';
+export const GLOBAL_CACHE_DIR_NAME = 'cache';
+export const GLOBAL_CACHE_TIERS = ['providers', 'projects', 'schemas', 'deepagents', 'plugins'];
+export const LEGACY_GLOBAL_CONFIG_DIR_NAME = 'codesdd';
+export const LEGACY_GLOBAL_CONFIG_FILE_NAME = 'config.json';
 const DEFAULT_CONFIG = {
     featureFlags: {},
     profile: 'core',
     delivery: 'both',
 };
+function resolveHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+function isTomlObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stripInlineComment(input) {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && inDouble) {
+            escaped = true;
+            continue;
+        }
+        if (ch === '\'' && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (ch === '#' && !inSingle && !inDouble) {
+            return input.slice(0, i).trimEnd();
+        }
+    }
+    return input.trimEnd();
+}
+function parseTomlKeyPath(raw) {
+    const parts = [];
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new SyntaxError('Invalid TOML key: empty key');
+    }
+    let token = '';
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (escaped) {
+            token += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\' && inDouble) {
+            token += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '\'' && !inDouble) {
+            inSingle = !inSingle;
+            token += ch;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            token += ch;
+            continue;
+        }
+        if (ch === '.' && !inSingle && !inDouble) {
+            const piece = token.trim();
+            if (piece.length === 0) {
+                throw new SyntaxError(`Invalid TOML key: "${raw}"`);
+            }
+            parts.push(unquoteTomlKey(piece));
+            token = '';
+            continue;
+        }
+        token += ch;
+    }
+    if (inSingle || inDouble) {
+        throw new SyntaxError(`Invalid TOML key: unclosed quote in "${raw}"`);
+    }
+    const tail = token.trim();
+    if (tail.length === 0) {
+        throw new SyntaxError(`Invalid TOML key: "${raw}"`);
+    }
+    parts.push(unquoteTomlKey(tail));
+    return parts;
+}
+function unquoteTomlKey(raw) {
+    const trimmed = raw.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith('\'') && trimmed.endsWith('\''))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function setObjectPath(target, pathParts, value) {
+    let cursor = target;
+    for (let i = 0; i < pathParts.length - 1; i++) {
+        const key = pathParts[i];
+        const current = cursor[key];
+        if (!isTomlObject(current)) {
+            cursor[key] = {};
+        }
+        cursor = cursor[key];
+    }
+    cursor[pathParts[pathParts.length - 1]] = value;
+}
+function getObjectPath(target, pathParts) {
+    let cursor = target;
+    for (const part of pathParts) {
+        const value = cursor[part];
+        if (!isTomlObject(value)) {
+            cursor[part] = {};
+        }
+        cursor = cursor[part];
+    }
+    return cursor;
+}
+function parseTomlPrimitive(raw) {
+    const value = raw.trim();
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+        if (value.startsWith('"')) {
+            return JSON.parse(value);
+        }
+        return value.slice(1, -1);
+    }
+    if (value.startsWith('[') && value.endsWith(']')) {
+        const inner = value.slice(1, -1).trim();
+        if (!inner)
+            return [];
+        const tokens = [];
+        let token = '';
+        let inSingle = false;
+        let inDouble = false;
+        let escaped = false;
+        let depth = 0;
+        for (let i = 0; i < inner.length; i++) {
+            const ch = inner[i];
+            if (escaped) {
+                token += ch;
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\' && inDouble) {
+                token += ch;
+                escaped = true;
+                continue;
+            }
+            if (ch === '\'' && !inDouble) {
+                inSingle = !inSingle;
+                token += ch;
+                continue;
+            }
+            if (ch === '"' && !inSingle) {
+                inDouble = !inDouble;
+                token += ch;
+                continue;
+            }
+            if (!inSingle && !inDouble) {
+                if (ch === '[')
+                    depth++;
+                if (ch === ']')
+                    depth--;
+            }
+            if (ch === ',' && !inSingle && !inDouble && depth === 0) {
+                tokens.push(token.trim());
+                token = '';
+                continue;
+            }
+            token += ch;
+        }
+        if (token.trim().length > 0) {
+            tokens.push(token.trim());
+        }
+        return tokens.map((entry) => parseTomlPrimitive(entry));
+    }
+    if (/^[+-]?\d+$/.test(value)) {
+        return Number.parseInt(value, 10);
+    }
+    if (/^[+-]?\d+\.\d+$/.test(value)) {
+        return Number.parseFloat(value);
+    }
+    throw new SyntaxError(`Invalid TOML value: ${value}`);
+}
+function formatTomlKey(key) {
+    if (/^[A-Za-z0-9_-]+$/.test(key)) {
+        return key;
+    }
+    return JSON.stringify(key);
+}
+function formatTomlValue(value) {
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => formatTomlValue(item)).join(', ')}]`;
+    }
+    throw new TypeError('Unsupported TOML value type');
+}
+function appendTomlTable(lines, tablePath, tableValue) {
+    if (tablePath.length > 0) {
+        lines.push(`[${tablePath.map((part) => formatTomlKey(part)).join('.')}]`);
+    }
+    const childTables = [];
+    for (const [key, value] of Object.entries(tableValue)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            childTables.push({ path: [...tablePath, key], value: value });
+            continue;
+        }
+        lines.push(`${formatTomlKey(key)} = ${formatTomlValue(value)}`);
+    }
+    for (const child of childTables) {
+        lines.push('');
+        appendTomlTable(lines, child.path, child.value);
+    }
+}
+export function parseTomlContent(content) {
+    const result = {};
+    let activeTable = result;
+    const lines = content.split(/\r?\n/u);
+    for (const rawLine of lines) {
+        const line = stripInlineComment(rawLine).trim();
+        if (!line)
+            continue;
+        if (line.startsWith('[') && line.endsWith(']')) {
+            const tableName = line.slice(1, -1).trim();
+            if (!tableName) {
+                throw new SyntaxError('Invalid TOML table header: empty name');
+            }
+            activeTable = getObjectPath(result, parseTomlKeyPath(tableName));
+            continue;
+        }
+        const equalsIndex = line.indexOf('=');
+        if (equalsIndex <= 0) {
+            throw new SyntaxError(`Invalid TOML assignment: "${line}"`);
+        }
+        const keyRaw = line.slice(0, equalsIndex).trim();
+        const valueRaw = line.slice(equalsIndex + 1).trim();
+        const keyParts = parseTomlKeyPath(keyRaw);
+        setObjectPath(activeTable, keyParts, parseTomlPrimitive(valueRaw));
+    }
+    return result;
+}
+export function stringifyTomlContent(value) {
+    const lines = [];
+    appendTomlTable(lines, [], value);
+    return `${lines.join('\n').trim()}\n`;
+}
 /**
- * Gets the global configuration directory path following XDG Base Directory Specification.
- *
- * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
- * - Unix/macOS fallback: ~/.config/openspec/
- * - Windows fallback: %APPDATA%/openspec/
+ * Gets the canonical global runtime/configuration directory.
+ * This repository standardizes global runtime state under ~/.codesdd.
  */
 export function getGlobalConfigDir() {
-    // XDG_CONFIG_HOME takes precedence on all platforms when explicitly set
+    return path.join(resolveHomeDir(), GLOBAL_CONFIG_DIR_NAME);
+}
+/**
+ * Gets the legacy XDG-compatible JSON config directory.
+ * This path is kept only for read compatibility with pre-~/.codesdd installs.
+ */
+export function getLegacyGlobalConfigDir() {
     const xdgConfigHome = process.env.XDG_CONFIG_HOME;
     if (xdgConfigHome) {
-        return path.join(xdgConfigHome, GLOBAL_CONFIG_DIR_NAME);
+        return path.join(xdgConfigHome, LEGACY_GLOBAL_CONFIG_DIR_NAME);
     }
     const platform = os.platform();
     if (platform === 'win32') {
-        // Windows: use %APPDATA%
         const appData = process.env.APPDATA;
         if (appData) {
-            return path.join(appData, GLOBAL_CONFIG_DIR_NAME);
+            return path.join(appData, LEGACY_GLOBAL_CONFIG_DIR_NAME);
         }
-        // Fallback for Windows if APPDATA is not set
-        return path.join(os.homedir(), 'AppData', 'Roaming', GLOBAL_CONFIG_DIR_NAME);
+        return path.join(resolveHomeDir(), 'AppData', 'Roaming', LEGACY_GLOBAL_CONFIG_DIR_NAME);
     }
-    // Unix/macOS fallback: ~/.config
-    return path.join(os.homedir(), '.config', GLOBAL_CONFIG_DIR_NAME);
+    return path.join(resolveHomeDir(), '.config', LEGACY_GLOBAL_CONFIG_DIR_NAME);
 }
 /**
  * Gets the global data directory path following XDG Base Directory Specification.
  * Used for user data like schema overrides.
  *
- * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
- * - Unix/macOS fallback: ~/.local/share/openspec/
- * - Windows fallback: %LOCALAPPDATA%/openspec/
+ * - All platforms: $XDG_DATA_HOME/legacy-spec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/legacy-spec/
+ * - Windows fallback: %LOCALAPPDATA%/legacy-spec/
  */
 export function getGlobalDataDir() {
     // XDG_DATA_HOME takes precedence on all platforms when explicitly set
@@ -58,17 +320,73 @@ export function getGlobalDataDir() {
             return path.join(localAppData, GLOBAL_DATA_DIR_NAME);
         }
         // Fallback for Windows if LOCALAPPDATA is not set
-        return path.join(os.homedir(), 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+        return path.join(resolveHomeDir(), 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
     }
     // Unix/macOS fallback: ~/.local/share
-    return path.join(os.homedir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
+    return path.join(resolveHomeDir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
 }
 /**
- * Gets the path to the global config file.
+ * Gets the path to the canonical global config TOML file.
  */
 export function getGlobalConfigPath() {
     return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE_NAME);
 }
+/**
+ * Gets the global cache directory path under ~/.codesdd/cache.
+ */
+export function getGlobalCacheDir() {
+    return path.join(getGlobalConfigDir(), GLOBAL_CACHE_DIR_NAME);
+}
+/**
+ * Gets all tier directory paths for the global cache layout.
+ */
+export function getGlobalCacheTierDirs() {
+    return GLOBAL_CACHE_TIERS.reduce((acc, tier) => {
+        acc[tier] = path.join(getGlobalCacheDir(), tier);
+        return acc;
+    }, {});
+}
+/**
+ * Ensures ~/.codesdd/cache and all known tier directories exist.
+ */
+export function ensureGlobalCacheLayout() {
+    const cacheRoot = getGlobalCacheDir();
+    if (!fs.existsSync(cacheRoot)) {
+        fs.mkdirSync(cacheRoot, { recursive: true });
+    }
+    const tiers = getGlobalCacheTierDirs();
+    for (const tierPath of Object.values(tiers)) {
+        if (!fs.existsSync(tierPath)) {
+            fs.mkdirSync(tierPath, { recursive: true });
+        }
+    }
+    return tiers;
+}
+/**
+ * Creates a stable project fingerprint for cache partitioning.
+ */
+export function createProjectFingerprint(projectRoot) {
+    const normalizedRoot = path.resolve(projectRoot);
+    return createHash('sha256').update(normalizedRoot).digest('hex').slice(0, 16);
+}
+/**
+ * Gets the path to the legacy global config JSON file.
+ */
+export function getLegacyGlobalConfigPath() {
+    return path.join(getLegacyGlobalConfigDir(), LEGACY_GLOBAL_CONFIG_FILE_NAME);
+}
+export function readGlobalConfigRaw() {
+    const primaryConfigPath = getGlobalConfigPath();
+    if (fs.existsSync(primaryConfigPath)) {
+        const content = fs.readFileSync(primaryConfigPath, 'utf-8');
+        return parseTomlContent(content);
+    }
+    const legacyConfigPath = getLegacyGlobalConfigPath();
+    if (fs.existsSync(legacyConfigPath)) {
+        return JSON.parse(fs.readFileSync(legacyConfigPath, 'utf-8'));
+    }
+    return {};
+}
 /**
  * Loads the global configuration from disk.
  * Returns default configuration if file doesn't exist or is invalid.
@@ -77,11 +395,10 @@ export function getGlobalConfigPath() {
 export function getGlobalConfig() {
     const configPath = getGlobalConfigPath();
     try {
-        if (!fs.existsSync(configPath)) {
+        const parsed = readGlobalConfigRaw();
+        if (Object.keys(parsed).length === 0 && !fs.existsSync(configPath) && !fs.existsSync(getLegacyGlobalConfigPath())) {
             return { ...DEFAULT_CONFIG };
         }
-        const content = fs.readFileSync(configPath, 'utf-8');
-        const parsed = JSON.parse(content);
         // Merge with defaults (loaded values take precedence)
         const merged = {
             ...DEFAULT_CONFIG,
@@ -104,7 +421,7 @@ export function getGlobalConfig() {
     catch (error) {
         // Log warning for parse errors, but not for missing files
         if (error instanceof SyntaxError) {
-            console.error(`Warning: Invalid JSON in ${configPath}, using defaults`);
+            console.error(`Warning: Invalid config in ${configPath}, using defaults`);
         }
         return { ...DEFAULT_CONFIG };
     }
@@ -120,6 +437,6 @@ export function saveGlobalConfig(config) {
     if (!fs.existsSync(configDir)) {
         fs.mkdirSync(configDir, { recursive: true });
     }
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    fs.writeFileSync(configPath, stringifyTomlContent(config), 'utf-8');
 }
 //# sourceMappingURL=global-config.js.map

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, GLOBAL_CACHE_DIR_NAME, GLOBAL_CACHE_TIERS, LEGACY_GLOBAL_CONFIG_DIR_NAME, LEGACY_GLOBAL_CONFIG_FILE_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalCacheDir, getGlobalCacheTierDirs, ensureGlobalCacheLayout, createProjectFingerprint, getLegacyGlobalConfigDir, getGlobalConfigPath, getLegacyGlobalConfigPath, getGlobalConfig, readGlobalConfigRaw, parseTomlContent, stringifyTomlContent, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,3 +1,3 @@
-// Core OpenSpec logic will be implemented here
-export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+// Core CodeSDD logic will be implemented here
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, GLOBAL_CACHE_DIR_NAME, GLOBAL_CACHE_TIERS, LEGACY_GLOBAL_CONFIG_DIR_NAME, LEGACY_GLOBAL_CONFIG_FILE_NAME, getGlobalConfigDir, getGlobalCacheDir, getGlobalCacheTierDirs, ensureGlobalCacheLayout, createProjectFingerprint, getLegacyGlobalConfigDir, getGlobalConfigPath, getLegacyGlobalConfigPath, getGlobalConfig, readGlobalConfigRaw, parseTomlContent, stringifyTomlContent, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
 //# sourceMappingURL=index.js.map

package/dist/core/init.d.ts

@@ -1,7 +1,7 @@
 /**
  * Init Command
  *
- * Sets up OpenSpec with Agent Skills and /opsx:* slash commands.
+ * Sets up CodeSDD with Agent Skills and /opsx:* slash commands.
  * This is the unified setup command that replaces both the old init and experimental commands.
  */
 type InitCommandOptions = {
@@ -9,16 +9,21 @@ type InitCommandOptions = {
     force?: boolean;
     interactive?: boolean;
     profile?: string;
+    allowNoToolsFallback?: boolean;
+    silent?: boolean;
 };
 export declare class InitCommand {
     private readonly toolsArg?;
     private readonly force;
     private readonly interactiveOption?;
     private readonly profileOverride?;
+    private readonly allowNoToolsFallback;
+    private readonly silent;
     constructor(options?: InitCommandOptions);
     execute(targetPath: string): Promise<void>;
     private validate;
     private canPromptInteractively;
+    private log;
     private resolveProfileOverride;
     private handleLegacyCleanup;
     private performLegacyCleanup;