lightspec 0.1.1

package/dist/core/configurators/slash/registry.js

@@ -0,0 +1,78 @@
+import { ClaudeSlashCommandConfigurator } from './claude.js';
+import { CodeBuddySlashCommandConfigurator } from './codebuddy.js';
+import { QoderSlashCommandConfigurator } from './qoder.js';
+import { CursorSlashCommandConfigurator } from './cursor.js';
+import { WindsurfSlashCommandConfigurator } from './windsurf.js';
+import { KiloCodeSlashCommandConfigurator } from './kilocode.js';
+import { OpenCodeSlashCommandConfigurator } from './opencode.js';
+import { CodexSlashCommandConfigurator } from './codex.js';
+import { GitHubCopilotSlashCommandConfigurator } from './github-copilot.js';
+import { AmazonQSlashCommandConfigurator } from './amazon-q.js';
+import { FactorySlashCommandConfigurator } from './factory.js';
+import { GeminiSlashCommandConfigurator } from './gemini.js';
+import { AuggieSlashCommandConfigurator } from './auggie.js';
+import { ClineSlashCommandConfigurator } from './cline.js';
+import { CrushSlashCommandConfigurator } from './crush.js';
+import { CostrictSlashCommandConfigurator } from './costrict.js';
+import { QwenSlashCommandConfigurator } from './qwen.js';
+import { RooCodeSlashCommandConfigurator } from './roocode.js';
+import { AntigravitySlashCommandConfigurator } from './antigravity.js';
+import { IflowSlashCommandConfigurator } from './iflow.js';
+import { ContinueSlashCommandConfigurator } from './continue.js';
+export class SlashCommandRegistry {
+    static configurators = new Map();
+    static {
+        const claude = new ClaudeSlashCommandConfigurator();
+        const codeBuddy = new CodeBuddySlashCommandConfigurator();
+        const qoder = new QoderSlashCommandConfigurator();
+        const cursor = new CursorSlashCommandConfigurator();
+        const windsurf = new WindsurfSlashCommandConfigurator();
+        const kilocode = new KiloCodeSlashCommandConfigurator();
+        const opencode = new OpenCodeSlashCommandConfigurator();
+        const codex = new CodexSlashCommandConfigurator();
+        const githubCopilot = new GitHubCopilotSlashCommandConfigurator();
+        const amazonQ = new AmazonQSlashCommandConfigurator();
+        const factory = new FactorySlashCommandConfigurator();
+        const gemini = new GeminiSlashCommandConfigurator();
+        const auggie = new AuggieSlashCommandConfigurator();
+        const cline = new ClineSlashCommandConfigurator();
+        const crush = new CrushSlashCommandConfigurator();
+        const costrict = new CostrictSlashCommandConfigurator();
+        const qwen = new QwenSlashCommandConfigurator();
+        const roocode = new RooCodeSlashCommandConfigurator();
+        const antigravity = new AntigravitySlashCommandConfigurator();
+        const iflow = new IflowSlashCommandConfigurator();
+        const continueTool = new ContinueSlashCommandConfigurator();
+        this.configurators.set(claude.toolId, claude);
+        this.configurators.set(codeBuddy.toolId, codeBuddy);
+        this.configurators.set(qoder.toolId, qoder);
+        this.configurators.set(cursor.toolId, cursor);
+        this.configurators.set(windsurf.toolId, windsurf);
+        this.configurators.set(kilocode.toolId, kilocode);
+        this.configurators.set(opencode.toolId, opencode);
+        this.configurators.set(codex.toolId, codex);
+        this.configurators.set(githubCopilot.toolId, githubCopilot);
+        this.configurators.set(amazonQ.toolId, amazonQ);
+        this.configurators.set(factory.toolId, factory);
+        this.configurators.set(gemini.toolId, gemini);
+        this.configurators.set(auggie.toolId, auggie);
+        this.configurators.set(cline.toolId, cline);
+        this.configurators.set(crush.toolId, crush);
+        this.configurators.set(costrict.toolId, costrict);
+        this.configurators.set(qwen.toolId, qwen);
+        this.configurators.set(roocode.toolId, roocode);
+        this.configurators.set(antigravity.toolId, antigravity);
+        this.configurators.set(iflow.toolId, iflow);
+        this.configurators.set(continueTool.toolId, continueTool);
+    }
+    static register(configurator) {
+        this.configurators.set(configurator.toolId, configurator);
+    }
+    static get(toolId) {
+        return this.configurators.get(toolId);
+    }
+    static getAll() {
+        return Array.from(this.configurators.values());
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/core/configurators/slash/roocode.d.ts

@@ -0,0 +1,9 @@
+import { SlashCommandConfigurator } from './base.js';
+import { SlashCommandId } from '../../templates/index.js';
+export declare class RooCodeSlashCommandConfigurator extends SlashCommandConfigurator {
+    readonly toolId = "roocode";
+    readonly isAvailable = true;
+    protected getRelativePath(id: SlashCommandId): string;
+    protected getFrontmatter(id: SlashCommandId): string | undefined;
+}
+//# sourceMappingURL=roocode.d.ts.map

package/dist/core/configurators/slash/roocode.js

@@ -0,0 +1,23 @@
+import { SlashCommandConfigurator } from './base.js';
+const NEW_FILE_PATHS = {
+    proposal: '.roo/commands/lightspec-proposal.md',
+    apply: '.roo/commands/lightspec-apply.md',
+    archive: '.roo/commands/lightspec-archive.md'
+};
+export class RooCodeSlashCommandConfigurator extends SlashCommandConfigurator {
+    toolId = 'roocode';
+    isAvailable = true;
+    getRelativePath(id) {
+        return NEW_FILE_PATHS[id];
+    }
+    getFrontmatter(id) {
+        const descriptions = {
+            proposal: 'Scaffold a new LightSpec change and validate strictly.',
+            apply: 'Implement an approved LightSpec change and keep tasks in sync.',
+            archive: 'Archive a deployed LightSpec change and update specs.'
+        };
+        const description = descriptions[id];
+        return `# LightSpec: ${id.charAt(0).toUpperCase() + id.slice(1)}\n\n${description}`;
+    }
+}
+//# sourceMappingURL=roocode.js.map

package/dist/core/configurators/slash/toml-base.d.ts

@@ -0,0 +1,10 @@
+import { SlashCommandConfigurator } from './base.js';
+import { SlashCommandId } from '../../templates/index.js';
+export declare abstract class TomlSlashCommandConfigurator extends SlashCommandConfigurator {
+    protected getFrontmatter(_id: SlashCommandId): string | undefined;
+    protected abstract getDescription(id: SlashCommandId): string;
+    generateAll(projectPath: string, _lightspecDir: string): Promise<string[]>;
+    private generateTOML;
+    protected updateBody(filePath: string, body: string): Promise<void>;
+}
+//# sourceMappingURL=toml-base.d.ts.map

package/dist/core/configurators/slash/toml-base.js

@@ -0,0 +1,53 @@
+import { FileSystemUtils } from '../../../utils/file-system.js';
+import { SlashCommandConfigurator } from './base.js';
+import { LIGHTSPEC_MARKERS } from '../../config.js';
+export class TomlSlashCommandConfigurator extends SlashCommandConfigurator {
+    getFrontmatter(_id) {
+        // TOML doesn't use separate frontmatter - it's all in one structure
+        return undefined;
+    }
+    // Override to generate TOML format with markers inside the prompt field
+    async generateAll(projectPath, _lightspecDir) {
+        const createdOrUpdated = [];
+        for (const target of this.getTargets()) {
+            const body = this.getBody(target.id);
+            const filePath = FileSystemUtils.joinPath(projectPath, target.path);
+            if (await FileSystemUtils.fileExists(filePath)) {
+                await this.updateBody(filePath, body);
+            }
+            else {
+                const tomlContent = this.generateTOML(target.id, body);
+                await FileSystemUtils.writeFile(filePath, tomlContent);
+            }
+            createdOrUpdated.push(target.path);
+        }
+        return createdOrUpdated;
+    }
+    generateTOML(id, body) {
+        const description = this.getDescription(id);
+        // TOML format with triple-quoted string for multi-line prompt
+        // Markers are inside the prompt value
+        return `description = "${description}"
+
+prompt = """
+${LIGHTSPEC_MARKERS.start}
+${body}
+${LIGHTSPEC_MARKERS.end}
+"""
+`;
+    }
+    // Override updateBody to handle TOML format
+    async updateBody(filePath, body) {
+        const content = await FileSystemUtils.readFile(filePath);
+        const startIndex = content.indexOf(LIGHTSPEC_MARKERS.start);
+        const endIndex = content.indexOf(LIGHTSPEC_MARKERS.end);
+        if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+            throw new Error(`Missing LightSpec markers in ${filePath}`);
+        }
+        const before = content.slice(0, startIndex + LIGHTSPEC_MARKERS.start.length);
+        const after = content.slice(endIndex);
+        const updatedContent = `${before}\n${body}\n${after}`;
+        await FileSystemUtils.writeFile(filePath, updatedContent);
+    }
+}
+//# sourceMappingURL=toml-base.js.map

package/dist/core/configurators/slash/windsurf.d.ts

@@ -0,0 +1,9 @@
+import { SlashCommandConfigurator } from './base.js';
+import { SlashCommandId } from '../../templates/index.js';
+export declare class WindsurfSlashCommandConfigurator extends SlashCommandConfigurator {
+    readonly toolId = "windsurf";
+    readonly isAvailable = true;
+    protected getRelativePath(id: SlashCommandId): string;
+    protected getFrontmatter(id: SlashCommandId): string | undefined;
+}
+//# sourceMappingURL=windsurf.d.ts.map

package/dist/core/configurators/slash/windsurf.js

@@ -0,0 +1,23 @@
+import { SlashCommandConfigurator } from './base.js';
+const FILE_PATHS = {
+    proposal: '.windsurf/workflows/lightspec-proposal.md',
+    apply: '.windsurf/workflows/lightspec-apply.md',
+    archive: '.windsurf/workflows/lightspec-archive.md'
+};
+export class WindsurfSlashCommandConfigurator extends SlashCommandConfigurator {
+    toolId = 'windsurf';
+    isAvailable = true;
+    getRelativePath(id) {
+        return FILE_PATHS[id];
+    }
+    getFrontmatter(id) {
+        const descriptions = {
+            proposal: 'Scaffold a new LightSpec change and validate strictly.',
+            apply: 'Implement an approved LightSpec change and keep tasks in sync.',
+            archive: 'Archive a deployed LightSpec change and update specs.'
+        };
+        const description = descriptions[id];
+        return `---\ndescription: ${description}\nauto_execution_mode: 3\n---`;
+    }
+}
+//# sourceMappingURL=windsurf.js.map

package/dist/core/converters/json-converter.d.ts

@@ -0,0 +1,6 @@
+export declare class JsonConverter {
+    convertSpecToJson(filePath: string): string;
+    convertChangeToJson(filePath: string): Promise<string>;
+    private extractNameFromPath;
+}
+//# sourceMappingURL=json-converter.d.ts.map

package/dist/core/converters/json-converter.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { MarkdownParser } from '../parsers/markdown-parser.js';
+import { ChangeParser } from '../parsers/change-parser.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export class JsonConverter {
+    convertSpecToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const parser = new MarkdownParser(content);
+        const specName = this.extractNameFromPath(filePath);
+        const spec = parser.parseSpec(specName);
+        const jsonSpec = {
+            ...spec,
+            metadata: {
+                ...spec.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonSpec, null, 2);
+    }
+    async convertChangeToJson(filePath) {
+        const content = readFileSync(filePath, 'utf-8');
+        const changeName = this.extractNameFromPath(filePath);
+        const changeDir = path.dirname(filePath);
+        const parser = new ChangeParser(content, changeDir);
+        const change = await parser.parseChangeWithDeltas(changeName);
+        const jsonChange = {
+            ...change,
+            metadata: {
+                ...change.metadata,
+                sourcePath: filePath,
+            },
+        };
+        return JSON.stringify(jsonChange, null, 2);
+    }
+    extractNameFromPath(filePath) {
+        const normalizedPath = FileSystemUtils.toPosixPath(filePath);
+        const parts = normalizedPath.split('/');
+        for (let i = parts.length - 1; i >= 0; i--) {
+            if (parts[i] === 'specs' || parts[i] === 'changes') {
+                if (i < parts.length - 1) {
+                    return parts[i + 1];
+                }
+            }
+        }
+        const fileName = parts[parts.length - 1] ?? '';
+        const dotIndex = fileName.lastIndexOf('.');
+        return dotIndex > 0 ? fileName.slice(0, dotIndex) : fileName;
+    }
+}
+//# sourceMappingURL=json-converter.js.map

package/dist/core/global-config.d.ts

@@ -0,0 +1,39 @@
+export declare const GLOBAL_CONFIG_DIR_NAME = "lightspec";
+export declare const GLOBAL_CONFIG_FILE_NAME = "config.json";
+export declare const GLOBAL_DATA_DIR_NAME = "lightspec";
+export interface GlobalConfig {
+    featureFlags?: Record<string, boolean>;
+}
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/lightspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/lightspec/
+ * - Windows fallback: %APPDATA%/lightspec/
+ */
+export declare function getGlobalConfigDir(): string;
+/**
+ * Gets the global data directory path following XDG Base Directory Specification.
+ * Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/lightspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/lightspec/
+ * - Windows fallback: %LOCALAPPDATA%/lightspec/
+ */
+export declare function getGlobalDataDir(): string;
+/**
+ * Gets the path to the global config file.
+ */
+export declare function getGlobalConfigPath(): string;
+/**
+ * Loads the global configuration from disk.
+ * Returns default configuration if file doesn't exist or is invalid.
+ * Merges loaded config with defaults to ensure new fields are available.
+ */
+export declare function getGlobalConfig(): GlobalConfig;
+/**
+ * Saves the global configuration to disk.
+ * Creates the config directory if it doesn't exist.
+ */
+export declare function saveGlobalConfig(config: GlobalConfig): void;
+//# sourceMappingURL=global-config.d.ts.map

package/dist/core/global-config.js

@@ -0,0 +1,115 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+// Constants
+export const GLOBAL_CONFIG_DIR_NAME = 'lightspec';
+export const GLOBAL_CONFIG_FILE_NAME = 'config.json';
+export const GLOBAL_DATA_DIR_NAME = 'lightspec';
+const DEFAULT_CONFIG = {
+    featureFlags: {}
+};
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/lightspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/lightspec/
+ * - Windows fallback: %APPDATA%/lightspec/
+ */
+export function getGlobalConfigDir() {
+    // XDG_CONFIG_HOME takes precedence on all platforms when explicitly set
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        return path.join(xdgConfigHome, 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);
+        }
+        // Fallback for Windows if APPDATA is not set
+        return path.join(os.homedir(), 'AppData', 'Roaming', GLOBAL_CONFIG_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.config
+    return path.join(os.homedir(), '.config', 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/lightspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/lightspec/
+ * - Windows fallback: %LOCALAPPDATA%/lightspec/
+ */
+export function getGlobalDataDir() {
+    // XDG_DATA_HOME takes precedence on all platforms when explicitly set
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+        return path.join(xdgDataHome, GLOBAL_DATA_DIR_NAME);
+    }
+    const platform = os.platform();
+    if (platform === 'win32') {
+        // Windows: use %LOCALAPPDATA%
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            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);
+    }
+    // Unix/macOS fallback: ~/.local/share
+    return path.join(os.homedir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
+}
+/**
+ * Gets the path to the global config file.
+ */
+export function getGlobalConfigPath() {
+    return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE_NAME);
+}
+/**
+ * Loads the global configuration from disk.
+ * Returns default configuration if file doesn't exist or is invalid.
+ * Merges loaded config with defaults to ensure new fields are available.
+ */
+export function getGlobalConfig() {
+    const configPath = getGlobalConfigPath();
+    try {
+        if (!fs.existsSync(configPath)) {
+            return { ...DEFAULT_CONFIG };
+        }
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Merge with defaults (loaded values take precedence)
+        return {
+            ...DEFAULT_CONFIG,
+            ...parsed,
+            // Deep merge featureFlags
+            featureFlags: {
+                ...DEFAULT_CONFIG.featureFlags,
+                ...(parsed.featureFlags || {})
+            }
+        };
+    }
+    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`);
+        }
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Saves the global configuration to disk.
+ * Creates the config directory if it doesn't exist.
+ */
+export function saveGlobalConfig(config) {
+    const configDir = getGlobalConfigDir();
+    const configPath = getGlobalConfigPath();
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+//# sourceMappingURL=global-config.js.map

package/dist/core/index.d.ts

@@ -0,0 +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';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,3 @@
+// Core LightSpec 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';
+//# sourceMappingURL=index.js.map

package/dist/core/init.d.ts

@@ -0,0 +1,52 @@
+type ToolLabel = {
+    primary: string;
+    annotation?: string;
+};
+type ToolWizardChoice = {
+    kind: 'heading' | 'info';
+    value: string;
+    label: ToolLabel;
+    selectable: false;
+} | {
+    kind: 'option';
+    value: string;
+    label: ToolLabel;
+    configured: boolean;
+    selectable: true;
+};
+type ToolWizardConfig = {
+    extendMode: boolean;
+    baseMessage: string;
+    choices: ToolWizardChoice[];
+    initialSelected?: string[];
+};
+type ToolSelectionPrompt = (config: ToolWizardConfig) => Promise<string[]>;
+type InitCommandOptions = {
+    prompt?: ToolSelectionPrompt;
+    tools?: string;
+};
+export declare class InitCommand {
+    private readonly prompt;
+    private readonly toolsArg?;
+    constructor(options?: InitCommandOptions);
+    execute(targetPath: string): Promise<void>;
+    private validate;
+    private getConfiguration;
+    private getSelectedTools;
+    private resolveToolsArg;
+    private promptForAITools;
+    private getExistingToolStates;
+    private isToolConfigured;
+    private createDirectoryStructure;
+    private generateFiles;
+    private ensureTemplateFiles;
+    private writeTemplateFiles;
+    private configureAITools;
+    private configureRootAgentsStub;
+    private displaySuccessMessage;
+    private formatToolNames;
+    private renderBanner;
+    private startSpinner;
+}
+export {};
+//# sourceMappingURL=init.d.ts.map