create-specfuse 0.2.3

package/dist/stacks/scala-sbt.js

@@ -0,0 +1,68 @@
+export const scalaSbtStack = {
+    id: 'scala-sbt',
+    label: 'Scala (sbt)',
+    languages: ['Scala'],
+    architecture: 'Functional / Layered (ZIO / Cats Effect)',
+    commands: {
+        build: 'sbt compile',
+        test: 'sbt test',
+        lint: 'sbt scalafmtCheck',
+        format: 'sbt scalafmt',
+    },
+    errorHandling: 'Scala Either/Option + ZIO error channel + custom ADTs',
+    concurrency: 'Scala Future + ZIO fibers + Cats Effect IO',
+    permissions: [
+        'Bash(sbt *)',
+        'Bash(scala *)',
+        'Bash(scalac *)',
+    ],
+    gitignorePatterns: [
+        '/target/',
+        '/project/target/',
+        '.bsp/',
+        '.metals/',
+        '.bloop/',
+    ],
+    openspecContext: `Tech stack: Scala (sbt)
+Build: sbt compile
+Testing: sbt test
+Code style: scalafmt + scalafmtCheck
+Architecture: Functional / Layered (ZIO / Cats Effect)
+Error handling: Scala Either/Option + ZIO error channel + custom ADTs
+Concurrency: Scala Future + ZIO fibers + Cats Effect IO`,
+    openspecRules: {
+        proposal: [
+            'Always include a "Non-goals" section to explicitly scope out what this change does NOT do',
+            'Include "Trade-offs" section with at least 2 alternative approaches considered',
+            'Must reference affected subprojects/packages by name',
+            'Keep proposals under 800 words',
+        ],
+        design: [
+            'Must include a dependency diagram (ASCII or mermaid) showing module relationships',
+            'Must specify public API surface (traits, case classes, type signatures)',
+            'Must address error handling strategy for the change',
+            'Must address concurrency implications if applicable',
+        ],
+        specs: [
+            'Each spec must be independently testable',
+            'Specs must define both success and failure behaviors',
+            'Include boundary conditions and edge cases',
+            'Reference specific types/traits, not vague descriptions',
+        ],
+        tasks: [
+            'Break tasks into chunks of max 2 hours of work',
+            'Each task must have a clear "done" definition verifiable by running a command',
+            'Tasks must follow TDD order - write test first, then implement, then refactor',
+            'Every task must include a verification command (sbt test / specific test suite)',
+            'Mark blocking dependencies explicitly between tasks',
+        ],
+    },
+};
+export const scalaSbtDetectionConfig = {
+    stackId: 'scala-sbt',
+    markerFiles: ['build.sbt'],
+    markerDirs: ['project/'],
+    fileExtensions: ['.scala', '.sc'],
+    priority: 10,
+};
+//# sourceMappingURL=scala-sbt.js.map

package/dist/stacks/scala-sbt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scala-sbt.js","sourceRoot":"","sources":["../../src/stacks/scala-sbt.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,aAAa,GAAiB;IACzC,EAAE,EAAE,WAAW;IACf,KAAK,EAAE,aAAa;IACpB,SAAS,EAAE,CAAC,OAAO,CAAC;IACpB,YAAY,EAAE,0CAA0C;IACxD,QAAQ,EAAE;QACR,KAAK,EAAE,aAAa;QACpB,IAAI,EAAE,UAAU;QAChB,IAAI,EAAE,mBAAmB;QACzB,MAAM,EAAE,cAAc;KACvB;IACD,aAAa,EAAE,uDAAuD;IACtE,WAAW,EAAE,4CAA4C;IACzD,WAAW,EAAE;QACX,aAAa;QACb,eAAe;QACf,gBAAgB;KACjB;IACD,iBAAiB,EAAE;QACjB,UAAU;QACV,kBAAkB;QAClB,OAAO;QACP,UAAU;QACV,SAAS;KACV;IACD,eAAe,EAAE;;;;;;wDAMqC;IACtD,aAAa,EAAE;QACb,QAAQ,EAAE;YACR,2FAA2F;YAC3F,gFAAgF;YAChF,sDAAsD;YACtD,gCAAgC;SACjC;QACD,MAAM,EAAE;YACN,mFAAmF;YACnF,yEAAyE;YACzE,qDAAqD;YACrD,qDAAqD;SACtD;QACD,KAAK,EAAE;YACL,0CAA0C;YAC1C,sDAAsD;YACtD,4CAA4C;YAC5C,yDAAyD;SAC1D;QACD,KAAK,EAAE;YACL,gDAAgD;YAChD,+EAA+E;YAC/E,+EAA+E;YAC/E,iFAAiF;YACjF,qDAAqD;SACtD;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAoB;IACtD,OAAO,EAAE,WAAW;IACpB,WAAW,EAAE,CAAC,WAAW,CAAC;IAC1B,UAAU,EAAE,CAAC,UAAU,CAAC;IACxB,cAAc,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;IACjC,QAAQ,EAAE,EAAE;CACb,CAAC"}

package/dist/stacks/schema.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const stackCommandsSchema: z.ZodObject<{
+    build: z.ZodString;
+    test: z.ZodString;
+    lint: z.ZodString;
+    format: z.ZodOptional<z.ZodString>;
+    typecheck: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    build: string;
+    test: string;
+    lint: string;
+    format?: string | undefined;
+    typecheck?: string | undefined;
+}, {
+    build: string;
+    test: string;
+    lint: string;
+    format?: string | undefined;
+    typecheck?: string | undefined;
+}>;
+export declare const stackProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    languages: z.ZodArray<z.ZodString, "many">;
+    framework: z.ZodOptional<z.ZodString>;
+    architecture: z.ZodString;
+    commands: z.ZodObject<{
+        build: z.ZodString;
+        test: z.ZodString;
+        lint: z.ZodString;
+        format: z.ZodOptional<z.ZodString>;
+        typecheck: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        build: string;
+        test: string;
+        lint: string;
+        format?: string | undefined;
+        typecheck?: string | undefined;
+    }, {
+        build: string;
+        test: string;
+        lint: string;
+        format?: string | undefined;
+        typecheck?: string | undefined;
+    }>;
+    errorHandling: z.ZodString;
+    concurrency: z.ZodString;
+    permissions: z.ZodArray<z.ZodString, "many">;
+    gitignorePatterns: z.ZodArray<z.ZodString, "many">;
+    openspecContext: z.ZodString;
+    openspecRules: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+    languages: string[];
+    architecture: string;
+    commands: {
+        build: string;
+        test: string;
+        lint: string;
+        format?: string | undefined;
+        typecheck?: string | undefined;
+    };
+    errorHandling: string;
+    concurrency: string;
+    permissions: string[];
+    gitignorePatterns: string[];
+    openspecContext: string;
+    openspecRules: Record<string, string[]>;
+    framework?: string | undefined;
+}, {
+    id: string;
+    label: string;
+    languages: string[];
+    architecture: string;
+    commands: {
+        build: string;
+        test: string;
+        lint: string;
+        format?: string | undefined;
+        typecheck?: string | undefined;
+    };
+    errorHandling: string;
+    concurrency: string;
+    permissions: string[];
+    gitignorePatterns: string[];
+    openspecContext: string;
+    openspecRules: Record<string, string[]>;
+    framework?: string | undefined;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/stacks/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/stacks/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa7B,CAAC"}

package/dist/stacks/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const stackCommandsSchema = z.object({
+    build: z.string().min(1),
+    test: z.string().min(1),
+    lint: z.string().min(1),
+    format: z.string().optional(),
+    typecheck: z.string().optional(),
+});
+export const stackProfileSchema = z.object({
+    id: z.string().min(1).regex(/^[a-z0-9-]+$/, 'Must be kebab-case'),
+    label: z.string().min(1),
+    languages: z.array(z.string().min(1)).min(1),
+    framework: z.string().optional(),
+    architecture: z.string().min(1),
+    commands: stackCommandsSchema,
+    errorHandling: z.string().min(1),
+    concurrency: z.string().min(1),
+    permissions: z.array(z.string().min(1)).min(1),
+    gitignorePatterns: z.array(z.string().min(1)).min(1),
+    openspecContext: z.string().min(1),
+    openspecRules: z.record(z.string(), z.array(z.string().min(1))),
+});
+//# sourceMappingURL=schema.js.map

package/dist/stacks/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/stacks/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE,oBAAoB,CAAC;IACjE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,QAAQ,EAAE,mBAAmB;IAC7B,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,iBAAiB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpD,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAClC,aAAa,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;CAChE,CAAC,CAAC"}

package/dist/stacks/swift.d.ts

@@ -0,0 +1,5 @@
+import type { StackProfile } from '../types.js';
+import type { DetectionConfig } from './detect.js';
+export declare const swiftStack: StackProfile;
+export declare const swiftDetectionConfig: DetectionConfig;
+//# sourceMappingURL=swift.d.ts.map

package/dist/stacks/swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../src/stacks/swift.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,eAAO,MAAM,UAAU,EAAE,YA4DxB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAMlC,CAAC"}

package/dist/stacks/swift.js

@@ -0,0 +1,69 @@
+export const swiftStack = {
+    id: 'swift',
+    label: 'Swift (SPM)',
+    languages: ['Swift'],
+    architecture: 'Protocol-oriented / MVVM',
+    commands: {
+        build: 'swift build',
+        test: 'swift test',
+        lint: 'swiftlint',
+        format: 'swift-format format -r Sources/',
+    },
+    errorHandling: 'Swift Error protocol + Result type + do-try-catch',
+    concurrency: 'Swift structured concurrency (async/await + TaskGroup + actors)',
+    permissions: [
+        'Bash(swift *)',
+        'Bash(swiftlint *)',
+        'Bash(swift-format *)',
+        'Bash(xcodebuild *)',
+    ],
+    gitignorePatterns: [
+        '.build/',
+        '*.xcodeproj/',
+        '*.xcworkspace/',
+        'DerivedData/',
+        'Package.resolved',
+    ],
+    openspecContext: `Tech stack: Swift (Swift Package Manager)
+Build: swift build
+Testing: swift test
+Code style: swiftlint + swift-format
+Architecture: Protocol-oriented / MVVM
+Error handling: Swift Error protocol + Result type + do-try-catch
+Concurrency: Swift structured concurrency (async/await + TaskGroup + actors)`,
+    openspecRules: {
+        proposal: [
+            'Always include a "Non-goals" section to explicitly scope out what this change does NOT do',
+            'Include "Trade-offs" section with at least 2 alternative approaches considered',
+            'Must reference affected modules/targets by name',
+            'Keep proposals under 800 words',
+        ],
+        design: [
+            'Must include a dependency diagram (ASCII or mermaid) showing module relationships',
+            'Must specify public API surface (protocols, struct/class signatures)',
+            'Must address error handling strategy for the change',
+            'Must address concurrency implications if applicable',
+        ],
+        specs: [
+            'Each spec must be independently testable',
+            'Specs must define both success and failure behaviors',
+            'Include boundary conditions and edge cases',
+            'Reference specific types/protocols, not vague descriptions',
+        ],
+        tasks: [
+            'Break tasks into chunks of max 2 hours of work',
+            'Each task must have a clear "done" definition verifiable by running a command',
+            'Tasks must follow TDD order - write test first, then implement, then refactor',
+            'Every task must include a verification command (swift test / specific test target)',
+            'Mark blocking dependencies explicitly between tasks',
+        ],
+    },
+};
+export const swiftDetectionConfig = {
+    stackId: 'swift',
+    markerFiles: ['Package.swift'],
+    markerDirs: [],
+    fileExtensions: ['.swift'],
+    priority: 10,
+};
+//# sourceMappingURL=swift.js.map

package/dist/stacks/swift.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.js","sourceRoot":"","sources":["../../src/stacks/swift.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,UAAU,GAAiB;IACtC,EAAE,EAAE,OAAO;IACX,KAAK,EAAE,aAAa;IACpB,SAAS,EAAE,CAAC,OAAO,CAAC;IACpB,YAAY,EAAE,0BAA0B;IACxC,QAAQ,EAAE;QACR,KAAK,EAAE,aAAa;QACpB,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE,iCAAiC;KAC1C;IACD,aAAa,EAAE,mDAAmD;IAClE,WAAW,EAAE,iEAAiE;IAC9E,WAAW,EAAE;QACX,eAAe;QACf,mBAAmB;QACnB,sBAAsB;QACtB,oBAAoB;KACrB;IACD,iBAAiB,EAAE;QACjB,SAAS;QACT,cAAc;QACd,gBAAgB;QAChB,cAAc;QACd,kBAAkB;KACnB;IACD,eAAe,EAAE;;;;;;6EAM0D;IAC3E,aAAa,EAAE;QACb,QAAQ,EAAE;YACR,2FAA2F;YAC3F,gFAAgF;YAChF,iDAAiD;YACjD,gCAAgC;SACjC;QACD,MAAM,EAAE;YACN,mFAAmF;YACnF,sEAAsE;YACtE,qDAAqD;YACrD,qDAAqD;SACtD;QACD,KAAK,EAAE;YACL,0CAA0C;YAC1C,sDAAsD;YACtD,4CAA4C;YAC5C,4DAA4D;SAC7D;QACD,KAAK,EAAE;YACL,gDAAgD;YAChD,+EAA+E;YAC/E,+EAA+E;YAC/E,oFAAoF;YACpF,qDAAqD;SACtD;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAoB;IACnD,OAAO,EAAE,OAAO;IAChB,WAAW,EAAE,CAAC,eAAe,CAAC;IAC9B,UAAU,EAAE,EAAE;IACd,cAAc,EAAE,CAAC,QAAQ,CAAC;IAC1B,QAAQ,EAAE,EAAE;CACb,CAAC"}

package/dist/stacks/typescript-react.d.ts

@@ -0,0 +1,5 @@
+import type { StackProfile } from '../types.js';
+import type { DetectionConfig } from './detect.js';
+export declare const typescriptReactStack: StackProfile;
+export declare const typescriptReactDetectionConfig: DetectionConfig;
+//# sourceMappingURL=typescript-react.d.ts.map

package/dist/stacks/typescript-react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-react.d.ts","sourceRoot":"","sources":["../../src/stacks/typescript-react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,eAAO,MAAM,oBAAoB,EAAE,YAgElC,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eAM5C,CAAC"}

package/dist/stacks/typescript-react.js

@@ -0,0 +1,73 @@
+export const typescriptReactStack = {
+    id: 'typescript-react',
+    label: 'TypeScript + React',
+    languages: ['TypeScript'],
+    framework: 'React',
+    architecture: 'Component-based / Feature-sliced',
+    commands: {
+        build: 'npm run build',
+        test: 'npx vitest run',
+        lint: 'npx eslint .',
+        format: 'npx prettier --write .',
+        typecheck: 'npx tsc --noEmit',
+    },
+    errorHandling: 'TypeScript strict mode + Error boundaries + React Suspense',
+    concurrency: 'React concurrent features + async/await',
+    permissions: [
+        'Bash(npm test *)',
+        'Bash(npm run *)',
+        'Bash(npx vitest *)',
+        'Bash(npx tsc *)',
+        'Bash(npx eslint *)',
+        'Bash(npx prettier *)',
+    ],
+    gitignorePatterns: [
+        'node_modules/',
+        '/dist/',
+        '/build/',
+        '.next/',
+        '*.tsbuildinfo',
+    ],
+    openspecContext: `Tech stack: TypeScript + React frontend / full-stack
+Build: npm run build
+Testing: vitest
+Code style: ESLint + Prettier
+Architecture: Component-based / Feature-sliced
+Error handling: TypeScript strict mode + Error boundaries
+Concurrency: React concurrent features + async/await`,
+    openspecRules: {
+        proposal: [
+            'Always include a "Non-goals" section to explicitly scope out what this change does NOT do',
+            'Include "Trade-offs" section with at least 2 alternative approaches considered',
+            'Must reference affected components/modules by name',
+            'Keep proposals under 800 words',
+        ],
+        design: [
+            'Must include a component hierarchy diagram',
+            'Must specify public API surface (props interfaces, hook signatures)',
+            'Must address state management strategy',
+            'Must address accessibility (a11y) implications',
+        ],
+        specs: [
+            'Each spec must be independently testable',
+            'Specs must define both success and failure behaviors',
+            'Include boundary conditions and edge cases',
+            'Reference specific component/hook names, not vague descriptions',
+        ],
+        tasks: [
+            'Break tasks into chunks of max 2 hours of work',
+            'Each task must have a clear "done" definition verifiable by running a command',
+            'Tasks must follow TDD order - write test first, then implement, then refactor',
+            'Every task must include a verification command (npx vitest run / specific test)',
+            'Mark blocking dependencies explicitly between tasks',
+        ],
+    },
+};
+export const typescriptReactDetectionConfig = {
+    stackId: 'typescript-react',
+    markerFiles: ['package.json', 'tsconfig.json'],
+    markerDirs: [],
+    fileExtensions: ['.tsx', '.ts'],
+    priority: 20,
+};
+//# sourceMappingURL=typescript-react.js.map

package/dist/stacks/typescript-react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-react.js","sourceRoot":"","sources":["../../src/stacks/typescript-react.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,oBAAoB,GAAiB;IAChD,EAAE,EAAE,kBAAkB;IACtB,KAAK,EAAE,oBAAoB;IAC3B,SAAS,EAAE,CAAC,YAAY,CAAC;IACzB,SAAS,EAAE,OAAO;IAClB,YAAY,EAAE,kCAAkC;IAChD,QAAQ,EAAE;QACR,KAAK,EAAE,eAAe;QACtB,IAAI,EAAE,gBAAgB;QACtB,IAAI,EAAE,cAAc;QACpB,MAAM,EAAE,wBAAwB;QAChC,SAAS,EAAE,kBAAkB;KAC9B;IACD,aAAa,EAAE,4DAA4D;IAC3E,WAAW,EAAE,yCAAyC;IACtD,WAAW,EAAE;QACX,kBAAkB;QAClB,iBAAiB;QACjB,oBAAoB;QACpB,iBAAiB;QACjB,oBAAoB;QACpB,sBAAsB;KACvB;IACD,iBAAiB,EAAE;QACjB,eAAe;QACf,QAAQ;QACR,SAAS;QACT,QAAQ;QACR,eAAe;KAChB;IACD,eAAe,EAAE;;;;;;qDAMkC;IACnD,aAAa,EAAE;QACb,QAAQ,EAAE;YACR,2FAA2F;YAC3F,gFAAgF;YAChF,oDAAoD;YACpD,gCAAgC;SACjC;QACD,MAAM,EAAE;YACN,4CAA4C;YAC5C,qEAAqE;YACrE,wCAAwC;YACxC,gDAAgD;SACjD;QACD,KAAK,EAAE;YACL,0CAA0C;YAC1C,sDAAsD;YACtD,4CAA4C;YAC5C,iEAAiE;SAClE;QACD,KAAK,EAAE;YACL,gDAAgD;YAChD,+EAA+E;YAC/E,+EAA+E;YAC/E,iFAAiF;YACjF,qDAAqD;SACtD;KACF;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAoB;IAC7D,OAAO,EAAE,kBAAkB;IAC3B,WAAW,EAAE,CAAC,cAAc,EAAE,eAAe,CAAC;IAC9C,UAAU,EAAE,EAAE;IACd,cAAc,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC;IAC/B,QAAQ,EAAE,EAAE;CACb,CAAC"}

package/dist/templates/claude-md.d.ts

@@ -0,0 +1,4 @@
+import type { TemplateContext } from '../types.js';
+export declare function renderGrillReview(): string;
+export declare function composeCLAUDEmd(ctx: TemplateContext): string;
+//# sourceMappingURL=claude-md.d.ts.map

package/dist/templates/claude-md.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-md.d.ts","sourceRoot":"","sources":["../../src/templates/claude-md.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,eAAe,EAAE,MAAM,aAAa,CAAC;AAgJjE,wBAAgB,iBAAiB,IAAI,MAAM,CA+D1C;AAaD,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAgC5D"}

package/dist/templates/claude-md.js

@@ -0,0 +1,241 @@
+function renderTechStack(stack) {
+    const lines = [
+        '## Tech Stack',
+        ...stack.languages.map((l) => `- Language: ${l}`),
+    ];
+    if (stack.framework)
+        lines.push(`- Framework: ${stack.framework}`);
+    lines.push(`- Architecture: ${stack.architecture}`, `- Build: \`${stack.commands.build}\``, `- Test: \`${stack.commands.test}\``, `- Lint: \`${stack.commands.lint}\``);
+    if (stack.commands.format)
+        lines.push(`- Format: \`${stack.commands.format}\``);
+    if (stack.commands.typecheck)
+        lines.push(`- Typecheck: \`${stack.commands.typecheck}\``);
+    return lines.join('\n');
+}
+function renderCommitConvention() {
+    return `## Commit Convention
+- Use conventional commits: feat:, fix:, refactor:, test:, docs:, chore:
+- All commit messages in English`;
+}
+function renderPathA() {
+    return `### Path A: One-Shot Proposal
+
+When \`/opsx:propose\` is invoked:
+
+1. **MUST activate Superpowers \`brainstorming\` as a pre-requisite skill.**
+   - Ask ONE question at a time (Socratic method). Never fire multiple questions in a single turn.
+   - Proactively present 2-3 architectural alternatives with explicit trade-offs.
+   - **STOP brainstorming BEFORE its "Write design doc" step (step 6).** Do NOT write to \`docs/superpowers/specs/\`. All spec files are managed exclusively by OpenSpec.
+   - Only after human confirms the approach, generate ALL artifacts (proposal -> design -> specs -> tasks) in one pass.
+
+2. Every proposal artifact MUST contain:
+   - **Non-goals** section (what this change explicitly does NOT do)
+   - **Trade-offs** section (alternatives considered and why they were rejected)
+   - **Verification strategy** (how we know this change works)`;
+}
+function renderPathB() {
+    return `### Path B: Step-by-Step Change
+
+When \`/opsx:new\` is invoked:
+
+1. Follow the \`openspec-new-change\` skill steps normally: ask what to build, create the change directory, show status.
+
+2. **BEFORE drafting the first artifact (proposal), MUST activate Superpowers \`brainstorming\`.**
+   - Use Socratic questioning to clarify scope, non-goals, and trade-offs.
+   - **STOP brainstorming BEFORE its "Write design doc" step (step 6).** Do NOT write to \`docs/superpowers/specs/\`. All spec files are managed exclusively by OpenSpec.
+   - Only after the user confirms the approach, draft the proposal artifact.
+
+3. When \`/opsx:continue\` is invoked to advance to the next artifact:
+   - Read current \`openspec status --change <name>\` to find the next "ready" artifact.
+   - Fetch instructions via \`openspec instructions <artifact-id> --change <name>\`.
+   - For **proposal** artifacts: apply brainstorming rules (Non-goals, Trade-offs, Verification strategy).
+   - For **design** artifacts: MUST include dependency diagram, public API surface, error handling strategy.
+   - For **specs** artifacts: each spec must be independently testable with success + failure behaviors.
+   - For **tasks** artifacts: enforce TDD order, max 2-hour chunks, verification commands per task.
+   - After drafting each artifact, STOP and wait for user review before advancing.
+
+4. **Pace control: one artifact per \`/opsx:continue\` invocation.**
+   - Never auto-advance to the next artifact without explicit user confirmation.
+   - This is the key difference from Path A — the user controls the rhythm.`;
+}
+function renderExploration() {
+    return `### Exploration
+
+When \`/opsx:explore\` is invoked:
+
+1. Enter thinking-partner mode. No artifact creation, no directory scaffolding.
+2. Activate Superpowers \`brainstorming\` for structured exploration.
+3. Output is conversational — conclusions can later feed into Path A or Path B.
+
+4. **Worktree isolation (exploration):**
+   When exploration needs to produce actual code (PoC, prototype), SHOULD create a worktree:
+   - Exploration may generate substantial code that will ultimately be discarded
+   - Exploration involves modifying existing code to validate hypotheses
+   Discarding a worktree costs zero — prevents exploration artifacts from polluting the main branch.`;
+}
+function renderApplyPhase(stack) {
+    return `### Phase 2: Apply / Implement
+
+When \`/opsx:apply\` is invoked:
+
+1. **MUST activate Superpowers \`test-driven-development\` as a pre-requisite skill.**
+   - For every task in \`tasks.md\`, follow strict Red-Green-Refactor:
+     a. Write a failing test FIRST
+     b. Write minimal code to make it pass
+     c. Refactor while keeping tests green
+
+2. **MUST activate Superpowers \`verification-before-completion\` before marking ANY task done.**
+   - **IRON LAW: NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE.**
+   - Before checking off a task \`[x]\`, you MUST:
+     a. Run the actual verification command in the terminal (\`${stack.commands.test}\`)
+     b. Paste the raw output as evidence
+     c. Only then mark the task complete
+   - "I believe it works" or "it should pass" is NEVER acceptable.
+
+3. **Subagent discipline** (when using parallel agents):
+   - Each subagent works in its own git worktree
+   - Each subagent runs its own tests independently
+   - Main agent verifies integration after merging subagent work
+
+4. **Subagent-Driven Development trigger conditions:**
+   When ALL of the following are met, SHOULD enable subagent mode:
+   - \`tasks.md\` contains ≥ 6 pending implementation tasks
+   - Most tasks have no \`blocked by\` dependency on each other
+   - Tasks map to different modules/files with clear module boundaries
+   - Session context window is >40% consumed
+
+   Execution discipline when enabled:
+   - Each subagent works in its own isolated git worktree
+   - Each subagent independently follows TDD and runs its own tests
+   - Main agent performs two-stage review per subagent output (spec compliance → code quality)
+   - Main agent runs full integration tests after merging
+   - Subagents MUST NOT implement the same module in parallel; independent modules may be parallelized
+
+5. **Git Worktree isolation trigger conditions:**
+   When ANY of the following are met, SHOULD create a worktree before apply begins:
+   - Change involves destructive refactoring (replacing core modules, migrating data structures)
+   - Multiple \`/opsx:new\` changes are being worked on in parallel
+   - Rollback cost of failure is high (change affects multiple consumers)
+
+   Worktree is NOT needed when:
+   - Single-file bugfix
+   - Adding a new independent module (no impact on existing code)
+   - Documentation or configuration adjustments`;
+}
+function renderVerifyPhase(stack) {
+    return `### Phase 3: Verify / Archive
+
+Before \`/opsx:archive\`:
+
+1. Run \`/opsx:verify\` to validate implementation matches all specs
+2. Run full test suite (\`${stack.commands.test}\`) and paste evidence
+3. Run linter (\`${stack.commands.lint}\`) with zero warnings`;
+}
+export function renderGrillReview() {
+    return `### Pre-Apply Review (Grill)
+
+When all artifacts (proposal, design, specs, tasks) are complete, the AI MUST prompt:
+> "All artifacts are ready. Recommend running \`/grill-me\` for a pre-apply review before implementation. Or run \`/opsx:apply\` directly to skip review."
+
+If the user runs \`/opsx:apply\` without prior grill, this is treated as an implicit skip — no blocking.
+
+**Protocol:**
+
+1. **Backup**: Copy the change directory to \`.grill-backup/\` before grill begins. Clean stale backups if present.
+2. **Review**: Ask ONE question at a time. Each question includes:
+   - Problem classification: \`[blocking]\` or \`[non-blocking]\`
+   - The specific issue found
+   - A recommended answer
+   - A modification preview (dry-run diff showing what will change)
+3. **User response**: If the user accepts, write the change. Core principle: **user must see the final diff before any write.**
+4. **Cleanup**: Delete \`.grill-backup/\` after successful completion.
+
+**Review Dimensions** (select by relevance, not all required):
+- Scope boundary — are goals/non-goals clear with no ambiguity?
+- Error paths — are exceptions, edge cases, and failures covered?
+- Dependency risk — new dependencies assessed? Impact on existing modules?
+- Testability — can every spec be verified with current test infrastructure?
+- Security — input validation, permissions, data exposure risks?
+- Performance impact — O(n²), blocking IO, memory pressure?
+- Backward compatibility — any breaking changes to existing APIs/behaviors?
+
+**Problem Classification:**
+- **Blocking** (must resolve before apply): artifact contradictions, uncovered edge cases, missing error handling, security risks, untestable specs. User may override with explicit acknowledgment.
+- **Non-blocking** (recorded, not enforced): naming style, optional optimizations, alternative approaches, documentation wording.
+
+**Exit Commands:**
+- \`grill-stop\`: Exit grill, keep all modifications made so far.
+- \`grill-abort\`: Exit grill, rollback all modifications from \`.grill-backup/\`.
+- Ambiguous expressions ("stop", "算了"): AI MUST ask for clarification — "exit grill review, or abandon the entire change?"
+
+**Soft Limit:** After 15 questions, self-assess whether remaining issues are blocking-level. If none remain, proceed to summary.
+
+**Consistency Scan** (before summary):
+Run a final check across all artifacts for:
+- Reference integrity — every goal in proposal maps to design/specs/tasks
+- Terminology consistency — same concepts use same names throughout
+- Logical conflict detection — no artifact contradicts another
+
+If scan finds issues, continue grill to resolve them.
+
+**Summary Format** (on completion):
+\`\`\`
+## Grill Review Summary
+
+Blocking (resolved):
+- [dimension] description of resolved issue
+
+Suggestions (recorded, non-blocking):
+- [dimension] description of suggestion
+
+Modified artifacts: <list of changed files>
+
+Consistency scan: ✅ PASS
+
+Run /opsx:apply to start implementation.
+\`\`\``;
+}
+function renderGeneralRules() {
+    return `### General Rules
+
+- **Always run \`openspec\` commands from the project root directory.**
+- **Never skip TDD.** Even for "simple" changes. Especially for "simple" changes.
+- **Never trust memory over terminal output.** Always verify current state.
+- **One concern per commit.** Keep commits atomic and reversible.
+- **Fail loud, fail early.** Prefer compile-time errors over runtime surprises.
+- **Dependencies flow inward.** Domain logic never imports infrastructure.`;
+}
+export function composeCLAUDEmd(ctx) {
+    const sections = [
+        `# Project CLAUDE.md`,
+        '',
+        renderTechStack(ctx.stack),
+        '',
+        renderCommitConvention(),
+        '',
+        '---',
+        '',
+        '<!-- FUSION:START -->',
+        '## OpenSpec & Superpowers Composite Workflow Constraints',
+        '',
+        'This project enforces a fused OpenSpec + Superpowers engineering pipeline.',
+        'AI agents MUST follow these rules without exception.',
+        '',
+        renderPathA(),
+        '',
+        renderPathB(),
+        '',
+        renderExploration(),
+        '',
+        renderGrillReview(),
+        '',
+        renderApplyPhase(ctx.stack),
+        '',
+        renderVerifyPhase(ctx.stack),
+        '',
+        renderGeneralRules(),
+        '<!-- FUSION:END -->',
+    ];
+    return sections.join('\n') + '\n';
+}
+//# sourceMappingURL=claude-md.js.map

package/dist/templates/claude-md.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-md.js","sourceRoot":"","sources":["../../src/templates/claude-md.ts"],"names":[],"mappings":"AAEA,SAAS,eAAe,CAAC,KAAmB;IAC1C,MAAM,KAAK,GAAG;QACZ,eAAe;QACf,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC;KAClD,CAAC;IACF,IAAI,KAAK,CAAC,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,gBAAgB,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;IACnE,KAAK,CAAC,IAAI,CACR,mBAAmB,KAAK,CAAC,YAAY,EAAE,EACvC,cAAc,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,EACtC,aAAa,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,EACpC,aAAa,KAAK,CAAC,QAAQ,CAAC,IAAI,IAAI,CACrC,CAAC;IACF,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,eAAe,KAAK,CAAC,QAAQ,CAAC,MAAM,IAAI,CAAC,CAAC;IAChF,IAAI,KAAK,CAAC,QAAQ,CAAC,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,kBAAkB,KAAK,CAAC,QAAQ,CAAC,SAAS,IAAI,CAAC,CAAC;IACzF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,SAAS,sBAAsB;IAC7B,OAAO;;iCAEwB,CAAC;AAClC,CAAC;AAED,SAAS,WAAW;IAClB,OAAO;;;;;;;;;;;;;+DAasD,CAAC;AAChE,CAAC;AAED,SAAS,WAAW;IAClB,OAAO;;;;;;;;;;;;;;;;;;;;;;4EAsBmE,CAAC;AAC7E,CAAC;AAED,SAAS,iBAAiB;IACxB,OAAO;;;;;;;;;;;;qGAY4F,CAAC;AACtG,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAmB;IAC3C,OAAO;;;;;;;;;;;;;iEAawD,KAAK,CAAC,QAAQ,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAiCpC,CAAC;AACjD,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAmB;IAC5C,OAAO;;;;;4BAKmB,KAAK,CAAC,QAAQ,CAAC,IAAI;mBAC5B,KAAK,CAAC,QAAQ,CAAC,IAAI,wBAAwB,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6DF,CAAC;AACR,CAAC;AAED,SAAS,kBAAkB;IACzB,OAAO;;;;;;;2EAOkE,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,GAAoB;IAClD,MAAM,QAAQ,GAAG;QACf,qBAAqB;QACrB,EAAE;QACF,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC;QAC1B,EAAE;QACF,sBAAsB,EAAE;QACxB,EAAE;QACF,KAAK;QACL,EAAE;QACF,uBAAuB;QACvB,0DAA0D;QAC1D,EAAE;QACF,4EAA4E;QAC5E,sDAAsD;QACtD,EAAE;QACF,WAAW,EAAE;QACb,EAAE;QACF,WAAW,EAAE;QACb,EAAE;QACF,iBAAiB,EAAE;QACnB,EAAE;QACF,iBAAiB,EAAE;QACnB,EAAE;QACF,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC;QAC3B,EAAE;QACF,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC;QAC5B,EAAE;QACF,kBAAkB,EAAE;QACpB,qBAAqB;KACtB,CAAC;IACF,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AACpC,CAAC"}

package/dist/templates/claude-settings.d.ts

@@ -0,0 +1,3 @@
+import type { StackProfile } from '../types.js';
+export declare function composeClaudeSettings(stack: StackProfile): object;
+//# sourceMappingURL=claude-settings.d.ts.map

package/dist/templates/claude-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-settings.d.ts","sourceRoot":"","sources":["../../src/templates/claude-settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAsBhD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAMjE"}