@fission-ai/openspec 0.11.0 → 0.12.0

package/README.md

@@ -92,6 +92,7 @@ These tools have built-in OpenSpec commands. Select the OpenSpec integration whe
 |------|----------|
 | **Claude Code** | `/openspec:proposal`, `/openspec:apply`, `/openspec:archive` |
 | **Cursor** | `/openspec-proposal`, `/openspec-apply`, `/openspec-archive` |
+| **Factory Droid** | `/openspec-proposal`, `/openspec-apply`, `/openspec-archive` (`.factory/commands/`) |
 | **OpenCode** | `/openspec-proposal`, `/openspec-apply`, `/openspec-archive` |
 | **Kilo Code** | `/openspec-proposal.md`, `/openspec-apply.md`, `/openspec-archive.md` (`.kilocode/workflows/`) |
 | **Windsurf** | `/openspec-proposal`, `/openspec-apply`, `/openspec-archive` (`.windsurf/workflows/`) |

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import ora from 'ora';
 import path from 'path';
 import { promises as fs } from 'fs';
 import { InitCommand } from '../core/init.js';
+import { AI_TOOLS } from '../core/config.js';
 import { UpdateCommand } from '../core/update.js';
 import { ListCommand } from '../core/list.js';
 import { ArchiveCommand } from '../core/archive.js';
@@ -28,10 +29,13 @@ program.hook('preAction', (thisCommand) => {
         process.env.NO_COLOR = '1';
     }
 });
+const availableToolIds = AI_TOOLS.filter((tool) => tool.available).map((tool) => tool.value);
+const toolsOptionDescription = `Configure AI tools non-interactively. Use "all", "none", or a comma-separated list of: ${availableToolIds.join(', ')}`;
 program
     .command('init [path]')
     .description('Initialize OpenSpec in your project')
-    .action(async (targetPath = '.') => {
+    .option('--tools <tools>', toolsOptionDescription)
+    .action(async (targetPath = '.', options) => {
     try {
         // Validate that the path is a valid directory
         const resolvedPath = path.resolve(targetPath);
@@ -53,7 +57,9 @@ program
                 throw new Error(`Cannot access path "${targetPath}": ${error.message}`);
             }
         }
-        const initCommand = new InitCommand();
+        const initCommand = new InitCommand({
+            tools: options?.tools,
+        });
         await initCommand.execute(targetPath);
     }
     catch (error) {

package/dist/core/config.js

@@ -6,6 +6,7 @@ export const OPENSPEC_MARKERS = {
 export const AI_TOOLS = [
     { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code' },
     { name: 'Cursor', value: 'cursor', available: true, successLabel: 'Cursor' },
+    { name: 'Factory Droid', value: 'factory', available: true, successLabel: 'Factory Droid' },
     { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode' },
     { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code' },
     { name: 'Windsurf', value: 'windsurf', available: true, successLabel: 'Windsurf' },

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

@@ -12,6 +12,7 @@ export declare abstract class SlashCommandConfigurator {
     updateExisting(projectPath: string, _openspecDir: string): Promise<string[]>;
     protected abstract getRelativePath(id: SlashCommandId): string;
     protected abstract getFrontmatter(id: SlashCommandId): string | undefined;
+    protected getBody(id: SlashCommandId): string;
     resolveAbsolutePath(projectPath: string, id: SlashCommandId): string;
     protected updateBody(filePath: string, body: string): Promise<void>;
 }

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

@@ -13,7 +13,7 @@ export class SlashCommandConfigurator {
     async generateAll(projectPath, _openspecDir) {
         const createdOrUpdated = [];
         for (const target of this.getTargets()) {
-            const body = TemplateManager.getSlashCommandBody(target.id).trim();
+            const body = this.getBody(target.id);
             const filePath = FileSystemUtils.joinPath(projectPath, target.path);
             if (await FileSystemUtils.fileExists(filePath)) {
                 await this.updateBody(filePath, body);
@@ -37,13 +37,16 @@ export class SlashCommandConfigurator {
         for (const target of this.getTargets()) {
             const filePath = FileSystemUtils.joinPath(projectPath, target.path);
             if (await FileSystemUtils.fileExists(filePath)) {
-                const body = TemplateManager.getSlashCommandBody(target.id).trim();
+                const body = this.getBody(target.id);
                 await this.updateBody(filePath, body);
                 updated.push(target.path);
             }
         }
         return updated;
     }
+    getBody(id) {
+        return TemplateManager.getSlashCommandBody(id).trim();
+    }
     // Resolve absolute path for a given slash command target. Subclasses may override
     // to redirect to tool-specific locations (e.g., global directories).
     resolveAbsolutePath(projectPath, id) {

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

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

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

@@ -0,0 +1,35 @@
+import { SlashCommandConfigurator } from './base.js';
+const FILE_PATHS = {
+    proposal: '.factory/commands/openspec-proposal.md',
+    apply: '.factory/commands/openspec-apply.md',
+    archive: '.factory/commands/openspec-archive.md'
+};
+const FRONTMATTER = {
+    proposal: `---
+description: Scaffold a new OpenSpec change and validate strictly.
+argument-hint: request or feature description
+---`,
+    apply: `---
+description: Implement an approved OpenSpec change and keep tasks in sync.
+argument-hint: change-id
+---`,
+    archive: `---
+description: Archive a deployed OpenSpec change and update specs.
+argument-hint: change-id
+---`
+};
+export class FactorySlashCommandConfigurator extends SlashCommandConfigurator {
+    toolId = 'factory';
+    isAvailable = true;
+    getRelativePath(id) {
+        return FILE_PATHS[id];
+    }
+    getFrontmatter(id) {
+        return FRONTMATTER[id];
+    }
+    getBody(id) {
+        const baseBody = super.getBody(id);
+        return `${baseBody}\n\n$ARGUMENTS`;
+    }
+}
+//# sourceMappingURL=factory.js.map

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

@@ -6,6 +6,7 @@ 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';
 export class SlashCommandRegistry {
     static configurators = new Map();
     static {
@@ -17,6 +18,7 @@ export class SlashCommandRegistry {
         const codex = new CodexSlashCommandConfigurator();
         const githubCopilot = new GitHubCopilotSlashCommandConfigurator();
         const amazonQ = new AmazonQSlashCommandConfigurator();
+        const factory = new FactorySlashCommandConfigurator();
         this.configurators.set(claude.toolId, claude);
         this.configurators.set(cursor.toolId, cursor);
         this.configurators.set(windsurf.toolId, windsurf);
@@ -25,6 +27,7 @@ export class SlashCommandRegistry {
         this.configurators.set(codex.toolId, codex);
         this.configurators.set(githubCopilot.toolId, githubCopilot);
         this.configurators.set(amazonQ.toolId, amazonQ);
+        this.configurators.set(factory.toolId, factory);
     }
     static register(configurator) {
         this.configurators.set(configurator.toolId, configurator);

package/dist/core/init.d.ts

@@ -23,13 +23,17 @@ type ToolWizardConfig = {
 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;

package/dist/core/init.js

@@ -243,8 +243,10 @@ const toolSelectionWizard = createPrompt((config, done) => {
 });
 export class InitCommand {
     prompt;
+    toolsArg;
     constructor(options = {}) {
         this.prompt = options.prompt ?? ((config) => toolSelectionWizard(config));
+        this.toolsArg = options.tools;
     }
     async execute(targetPath) {
         const projectPath = path.resolve(targetPath);
@@ -295,9 +297,59 @@ export class InitCommand {
         return extendMode;
     }
     async getConfiguration(existingTools, extendMode) {
-        const selectedTools = await this.promptForAITools(existingTools, extendMode);
+        const selectedTools = await this.getSelectedTools(existingTools, extendMode);
         return { aiTools: selectedTools };
     }
+    async getSelectedTools(existingTools, extendMode) {
+        const nonInteractiveSelection = this.resolveToolsArg();
+        if (nonInteractiveSelection !== null) {
+            return nonInteractiveSelection;
+        }
+        // Fall back to interactive mode
+        return this.promptForAITools(existingTools, extendMode);
+    }
+    resolveToolsArg() {
+        if (typeof this.toolsArg === 'undefined') {
+            return null;
+        }
+        const raw = this.toolsArg.trim();
+        if (raw.length === 0) {
+            throw new Error('The --tools option requires a value. Use "all", "none", or a comma-separated list of tool IDs.');
+        }
+        const availableTools = AI_TOOLS.filter((tool) => tool.available);
+        const availableValues = availableTools.map((tool) => tool.value);
+        const availableSet = new Set(availableValues);
+        const availableList = ['all', 'none', ...availableValues].join(', ');
+        const lowerRaw = raw.toLowerCase();
+        if (lowerRaw === 'all') {
+            return availableValues;
+        }
+        if (lowerRaw === 'none') {
+            return [];
+        }
+        const tokens = raw
+            .split(',')
+            .map((token) => token.trim())
+            .filter((token) => token.length > 0);
+        if (tokens.length === 0) {
+            throw new Error('The --tools option requires at least one tool ID when not using "all" or "none".');
+        }
+        const normalizedTokens = tokens.map((token) => token.toLowerCase());
+        if (normalizedTokens.some((token) => token === 'all' || token === 'none')) {
+            throw new Error('Cannot combine reserved values "all" or "none" with specific tool IDs.');
+        }
+        const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
+        if (invalidTokens.length > 0) {
+            throw new Error(`Invalid tool(s): ${invalidTokens.join(', ')}. Available values: ${availableList}`);
+        }
+        const deduped = [];
+        for (const token of normalizedTokens) {
+            if (!deduped.includes(token)) {
+                deduped.push(token);
+            }
+        }
+        return deduped;
+    }
     async promptForAITools(existingTools, extendMode) {
         const availableTools = AI_TOOLS.filter((tool) => tool.available);
         const baseMessage = extendMode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fission-ai/openspec",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "openspec",