create-foundry-workspace 1.0.0

package/dist/cli/command.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { Command } from 'commander';
+import { defaultRegistry } from '../adapters/registry.js';
+import { CliOptionsSchema, WorkspaceConfigSchema } from '../config/schema.js';
+import { buildResolvedContext } from '../core/context.js';
+import { generateWorkspace } from '../core/generator.js';
+import { detectProjectEnvironment } from '../detection/detector.js';
+import { writeWorkspace } from '../io/writer.js';
+import { formatDryRunBanner, formatSuccessSummary } from './formatters.js';
+import { runInteractivePrompts } from './prompts.js';
+export async function runCli(argv = process.argv) {
+    const program = new Command();
+    program
+        .name('create-foundry-workspace')
+        .description('Deterministic, zero-LLM CLI for initializing AI-ready software development workspaces')
+        .version('1.0.0')
+        .argument('[directory]', 'Target directory to initialize')
+        .option('-n, --name <string>', 'Project name')
+        .option('-t, --type <type>', 'Application type (web | api | fullstack | cli | library | data-ml | mobile | custom)')
+        .option('-l, --lang <language>', 'Primary language (typescript | javascript | python | java | go | rust | other)')
+        .option('-r, --repo <repository>', 'Repository hosting (github | gitlab | none)', 'github')
+        .option('-s, --strictness <level>', 'Guardrail level (standard | strict)', 'standard')
+        .option('-a, --ai <adapters>', 'Comma-separated adapter IDs (e.g. claude,cursor,codex,gemini,agents,generic)')
+        .option('--dry-run', 'Preview generated files in memory without writing to disk', false)
+        .option('-f, --force', 'Overwrite existing files in target directory', false)
+        .option('-y, --yes', 'Accept defaults non-interactively', false);
+    program.parse(argv);
+    const rawOpts = program.opts();
+    const opts = CliOptionsSchema.parse(rawOpts);
+    // Check if directory argument was explicitly provided by the user
+    const explicitDirArg = program.args[0];
+    const initialTargetDir = explicitDirArg ? path.resolve(explicitDirArg) : process.cwd();
+    // 1. Detect project environment from filesystem markers
+    const detected = await detectProjectEnvironment(initialTargetDir);
+    const defaultAdapters = opts.ai
+        ? opts.ai
+            .split(',')
+            .map((s) => s.trim().toLowerCase())
+            .filter((s) => defaultRegistry.has(s))
+        : ['claude', 'cursor', 'agents'];
+    let config;
+    // 2. Determine interactive vs. non-interactive flow
+    const isNonInteractive = opts.yes || !process.stdout.isTTY || !!opts.name || !!opts.type || !!opts.lang;
+    if (isNonInteractive) {
+        const rawConfig = {
+            version: '1',
+            project: {
+                name: opts.name || detected.name,
+                type: (opts.type || detected.type),
+                language: (opts.lang || detected.language),
+            },
+            repository: (opts.repo || 'github'),
+            strictness: (opts.strictness || 'standard'),
+            adapters: defaultAdapters.length > 0 ? defaultAdapters : ['claude', 'cursor', 'agents'],
+        };
+        config = WorkspaceConfigSchema.parse(rawConfig);
+    }
+    else {
+        config = await runInteractivePrompts(detected, {
+            name: opts.name,
+            type: opts.type,
+            language: opts.lang,
+            repository: opts.repo,
+            strictness: opts.strictness,
+            adapters: defaultAdapters,
+        });
+    }
+    // 3. Resolve target directory:
+    // - If an explicit directory argument was passed (e.g. `create-foundry-workspace .` or `create-foundry-workspace my-dir`), resolve that.
+    // - If detected in an existing project (e.g. package.json exists in cwd) or project name matches current directory name, initialize in cwd (`.`).
+    // - Otherwise, create a new subfolder named after the project in cwd.
+    let targetDir;
+    if (explicitDirArg) {
+        targetDir = path.resolve(explicitDirArg);
+    }
+    else if (detected.isDetected || config.project.name === path.basename(process.cwd())) {
+        targetDir = process.cwd();
+    }
+    else {
+        targetDir = path.resolve(process.cwd(), config.project.name);
+    }
+    // 4. Resolve context and generate files (PURE IN-MEMORY)
+    const context = buildResolvedContext(config);
+    const generatedFiles = generateWorkspace(context, defaultRegistry);
+    // 5. Handle dry-run or write to disk (I/O BOUNDARY)
+    if (opts.dryRun) {
+        formatDryRunBanner(config.project.name, targetDir, generatedFiles);
+        return;
+    }
+    const writeResult = await writeWorkspace(targetDir, generatedFiles, {
+        dryRun: false,
+        force: opts.force,
+    });
+    formatSuccessSummary(targetDir, writeResult);
+}
+//# sourceMappingURL=command.js.map

package/dist/cli/formatters.d.ts

@@ -0,0 +1,5 @@
+import { GeneratedFile } from '../adapters/adapter.interface.js';
+import { WriteResult } from '../io/writer.js';
+export declare function formatDryRunBanner(name: string, targetDir: string, files: GeneratedFile[]): void;
+export declare function formatSuccessSummary(targetDir: string, result: WriteResult): void;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/cli/formatters.js

@@ -0,0 +1,30 @@
+export function formatDryRunBanner(name, targetDir, files) {
+    console.log(`\n============================================================`);
+    console.log(`  Foundry (create-foundry-workspace) — DRY RUN PREVIEW`);
+    console.log(`============================================================`);
+    console.log(`Project:          ${name}`);
+    console.log(`Target Directory: ${targetDir}`);
+    console.log(`Files to create:  ${files.length}`);
+    console.log(`Mode:             No disk writes performed (--dry-run enabled)\n`);
+    console.log(`Generated Workspace File Tree:`);
+    for (const file of files) {
+        console.log(`  + ${file.relativePath}`);
+    }
+    console.log(`============================================================\n`);
+}
+export function formatSuccessSummary(targetDir, result) {
+    console.log(`\n✔ AI Workspace initialized successfully in ${targetDir}`);
+    console.log(`  Created: ${result.written.length} files`);
+    if (result.skipped.length > 0) {
+        console.log(`  Skipped (existing): ${result.skipped.length} files (use --force to overwrite)`);
+    }
+    console.log(`\nGenerated files:`);
+    for (const path of result.written) {
+        console.log(`  + ${path}`);
+    }
+    console.log(`\nNext steps:`);
+    console.log(`  1. Open the project in Cursor, VS Code (Copilot), or Claude Code.`);
+    console.log(`  2. Review AGENTS.md and README.md.`);
+    console.log(`  3. Start developing!\n`);
+}
+//# sourceMappingURL=formatters.js.map

package/dist/cli/prompts.d.ts

@@ -0,0 +1,11 @@
+import { AppType, Language, Repository, Strictness, WorkspaceConfig } from '../config/schema.js';
+import { DetectedEnvironment } from '../detection/detector.js';
+export declare function runInteractivePrompts(detected: DetectedEnvironment, defaults: {
+    name?: string;
+    type?: AppType;
+    language?: Language;
+    repository?: Repository;
+    strictness?: Strictness;
+    adapters?: string[];
+}): Promise<WorkspaceConfig>;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/cli/prompts.js

@@ -0,0 +1,140 @@
+import * as p from '@clack/prompts';
+import { defaultRegistry } from '../adapters/registry.js';
+export async function runInteractivePrompts(detected, defaults) {
+    // Guard against headless/non-interactive terminals
+    if (!process.stdout.isTTY) {
+        return {
+            version: '1',
+            project: {
+                name: defaults.name || detected.name,
+                type: defaults.type || detected.type,
+                language: defaults.language || detected.language,
+            },
+            repository: defaults.repository || 'github',
+            strictness: defaults.strictness || 'standard',
+            adapters: defaults.adapters || defaultRegistry.getDefaultIds(),
+        };
+    }
+    p.intro('Foundry (create-foundry-workspace) v1.0.0');
+    // Step 1: Project Name
+    const initialName = defaults.name || (detected.name !== 'my-workspace' && detected.name !== 'Extentions' ? detected.name : 'my-app');
+    const nameInput = await p.text({
+        message: 'Project name:',
+        defaultValue: initialName,
+        placeholder: initialName,
+        validate: (val) => {
+            if (!val || !/^[a-zA-Z0-9_\-.]+$/.test(val)) {
+                return 'Project name must be alphanumeric with dashes/underscores/dots.';
+            }
+        },
+    });
+    if (p.isCancel(nameInput)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    // Step 2: Project type
+    const selectedType = await p.select({
+        message: 'Project type:',
+        options: [
+            { value: 'web', label: 'Web App', hint: 'Frontend / SPA' },
+            { value: 'api', label: 'Backend/API', hint: 'REST / GraphQL / RPC services' },
+            { value: 'fullstack', label: 'Full Stack', hint: 'Client + Server application' },
+            { value: 'cli', label: 'CLI', hint: 'Command-line tool or terminal binary' },
+            { value: 'library', label: 'Library/Package', hint: 'Reusable package' },
+            { value: 'data-ml', label: 'Data/ML', hint: 'Data pipelines & machine learning' },
+            { value: 'mobile', label: 'Mobile', hint: 'Native or cross-platform mobile app' },
+            { value: 'custom', label: 'Custom', hint: 'Custom architecture' },
+        ],
+        initialValue: defaults.type || detected.type,
+    });
+    if (p.isCancel(selectedType)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    // Step 3: Language
+    const selectedLang = await p.select({
+        message: 'Language:',
+        options: [
+            { value: 'typescript', label: 'TypeScript' },
+            { value: 'javascript', label: 'JavaScript' },
+            { value: 'python', label: 'Python' },
+            { value: 'java', label: 'Java' },
+            { value: 'go', label: 'Go' },
+            { value: 'rust', label: 'Rust' },
+            { value: 'other', label: 'Other' },
+        ],
+        initialValue: defaults.language || detected.language,
+    });
+    if (p.isCancel(selectedLang)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    // Step 4: AI workflow
+    const selectedAdapters = await p.multiselect({
+        message: 'AI workflow (Press Enter to default to Multi-agent / Generic):',
+        options: [
+            { value: 'agents', label: 'Multi-agent', hint: 'AGENTS.md open standard' },
+            { value: 'claude', label: 'Claude', hint: 'CLAUDE.md for Claude Code' },
+            { value: 'cursor', label: 'Cursor', hint: '.cursor/rules/ for Cursor IDE' },
+            { value: 'copilot', label: 'Copilot', hint: '.github/copilot-instructions.md for GitHub Copilot' },
+            { value: 'codex', label: 'Codex', hint: 'CODEX.md for OpenAI Codex' },
+            { value: 'gemini', label: 'Gemini', hint: 'GEMINI.md for Google Gemini CLI' },
+            { value: 'generic', label: 'Generic', hint: 'AI_INSTRUCTIONS.md for any tool' },
+        ],
+        required: false,
+    });
+    if (p.isCancel(selectedAdapters)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    const finalAdapters = Array.isArray(selectedAdapters) && selectedAdapters.length > 0
+        ? selectedAdapters
+        : ['agents'];
+    // Step 5: Repository
+    const selectedRepo = await p.select({
+        message: 'Repository:',
+        options: [
+            { value: 'github', label: 'GitHub', hint: '.github/ configuration' },
+            { value: 'gitlab', label: 'GitLab', hint: '.gitlab/ configuration' },
+            { value: 'none', label: 'None', hint: 'No remote repository config' },
+        ],
+        initialValue: defaults.repository || 'github',
+    });
+    if (p.isCancel(selectedRepo)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    // Step 6: Guardrail Strictness
+    const selectedStrictness = await p.select({
+        message: 'Guardrail Strictness:',
+        options: [
+            {
+                value: 'standard',
+                label: 'Standard',
+                hint: 'Modular architecture, build/test guidelines, basic security',
+            },
+            {
+                value: 'strict',
+                label: 'Strict',
+                hint: 'Mandatory tests, strict typing, destructive command restriction',
+            },
+        ],
+        initialValue: defaults.strictness || 'standard',
+    });
+    if (p.isCancel(selectedStrictness)) {
+        p.cancel('Initialization cancelled.');
+        process.exit(0);
+    }
+    return {
+        version: '1',
+        project: {
+            name: nameInput,
+            type: selectedType,
+            language: selectedLang,
+        },
+        repository: selectedRepo,
+        strictness: selectedStrictness,
+        adapters: finalAdapters,
+    };
+}
+//# sourceMappingURL=prompts.js.map

package/dist/config/defaults.d.ts

@@ -0,0 +1,8 @@
+import { AppType, Language, Strictness } from './schema.js';
+export declare const DEFAULT_APP_TYPE: AppType;
+export declare const DEFAULT_LANGUAGE: Language;
+export declare const DEFAULT_STRICTNESS: Strictness;
+export declare const DEFAULT_ADAPTERS: string[];
+export declare const SPEC_VERSION = "1";
+export declare const GENERATOR_NAME = "create-foundry-workspace";
+//# sourceMappingURL=defaults.d.ts.map

package/dist/config/defaults.js

@@ -0,0 +1,7 @@
+export const DEFAULT_APP_TYPE = 'fullstack';
+export const DEFAULT_LANGUAGE = 'typescript';
+export const DEFAULT_STRICTNESS = 'standard';
+export const DEFAULT_ADAPTERS = ['agents', 'cursor', 'claude', 'copilot'];
+export const SPEC_VERSION = '1';
+export const GENERATOR_NAME = 'create-foundry-workspace';
+//# sourceMappingURL=defaults.js.map

package/dist/config/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const AppTypeSchema: z.ZodEnum<["web", "api", "fullstack", "cli", "library", "data-ml", "mobile", "custom"]>;
+export type AppType = z.infer<typeof AppTypeSchema>;
+export declare const LanguageSchema: z.ZodEnum<["typescript", "javascript", "python", "java", "go", "rust", "other"]>;
+export type Language = z.infer<typeof LanguageSchema>;
+export declare const RepositorySchema: z.ZodEnum<["github", "gitlab", "none"]>;
+export type Repository = z.infer<typeof RepositorySchema>;
+export declare const StrictnessSchema: z.ZodEnum<["standard", "strict"]>;
+export type Strictness = z.infer<typeof StrictnessSchema>;
+export declare const WorkspaceConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["web", "api", "fullstack", "cli", "library", "data-ml", "mobile", "custom"]>;
+        language: z.ZodEnum<["typescript", "javascript", "python", "java", "go", "rust", "other"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom";
+        name: string;
+        language: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other";
+    }, {
+        type: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom";
+        name: string;
+        language: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other";
+    }>;
+    repository: z.ZodDefault<z.ZodEnum<["github", "gitlab", "none"]>>;
+    strictness: z.ZodDefault<z.ZodEnum<["standard", "strict"]>>;
+    adapters: z.ZodEffects<z.ZodDefault<z.ZodArray<z.ZodString, "many">>, string[], string[] | undefined>;
+}, "strip", z.ZodTypeAny, {
+    version: "1";
+    project: {
+        type: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom";
+        name: string;
+        language: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other";
+    };
+    repository: "github" | "gitlab" | "none";
+    strictness: "standard" | "strict";
+    adapters: string[];
+}, {
+    version: "1";
+    project: {
+        type: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom";
+        name: string;
+        language: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other";
+    };
+    repository?: "github" | "gitlab" | "none" | undefined;
+    strictness?: "standard" | "strict" | undefined;
+    adapters?: string[] | undefined;
+}>;
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+export interface CommandSet {
+    readonly build: string;
+    readonly test: string;
+    readonly dev: string;
+    readonly lint: string;
+}
+export interface ResolvedWorkspaceContext {
+    readonly config: WorkspaceConfig;
+    readonly commands: CommandSet;
+    readonly languageRules: string;
+    readonly appTypeRules: string;
+    readonly baseGuardrails: string;
+}
+export declare const CliOptionsSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["web", "api", "fullstack", "cli", "library", "data-ml", "mobile", "custom"]>>;
+    lang: z.ZodOptional<z.ZodEnum<["typescript", "javascript", "python", "java", "go", "rust", "other"]>>;
+    repo: z.ZodOptional<z.ZodEnum<["github", "gitlab", "none"]>>;
+    strictness: z.ZodOptional<z.ZodEnum<["standard", "strict"]>>;
+    ai: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<z.ZodBoolean>;
+    yes: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    dryRun: boolean;
+    force: boolean;
+    yes: boolean;
+    type?: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom" | undefined;
+    name?: string | undefined;
+    strictness?: "standard" | "strict" | undefined;
+    lang?: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other" | undefined;
+    repo?: "github" | "gitlab" | "none" | undefined;
+    ai?: string | undefined;
+}, {
+    type?: "web" | "api" | "fullstack" | "cli" | "library" | "data-ml" | "mobile" | "custom" | undefined;
+    name?: string | undefined;
+    strictness?: "standard" | "strict" | undefined;
+    lang?: "typescript" | "javascript" | "python" | "java" | "go" | "rust" | "other" | undefined;
+    repo?: "github" | "gitlab" | "none" | undefined;
+    ai?: string | undefined;
+    dryRun?: boolean | undefined;
+    force?: boolean | undefined;
+    yes?: boolean | undefined;
+}>;
+export type CliOptions = z.infer<typeof CliOptionsSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const AppTypeSchema = z.enum([
+    'web',
+    'api',
+    'fullstack',
+    'cli',
+    'library',
+    'data-ml',
+    'mobile',
+    'custom',
+]);
+export const LanguageSchema = z.enum([
+    'typescript',
+    'javascript',
+    'python',
+    'java',
+    'go',
+    'rust',
+    'other',
+]);
+export const RepositorySchema = z.enum(['github', 'gitlab', 'none']);
+export const StrictnessSchema = z.enum(['standard', 'strict']);
+export const WorkspaceConfigSchema = z.object({
+    version: z.literal('1'),
+    project: z.object({
+        name: z
+            .string()
+            .min(1, 'Project name is required')
+            .regex(/^[a-zA-Z0-9_\-.]+$/, 'Project name must be alphanumeric with dashes/underscores/dots'),
+        type: AppTypeSchema,
+        language: LanguageSchema,
+    }),
+    repository: RepositorySchema.default('github'),
+    strictness: StrictnessSchema.default('standard'),
+    adapters: z
+        .array(z.string().min(1))
+        .default(['agents'])
+        .transform((val) => (val.length === 0 ? ['agents'] : val)),
+});
+export const CliOptionsSchema = z.object({
+    name: z.string().optional(),
+    type: AppTypeSchema.optional(),
+    lang: LanguageSchema.optional(),
+    repo: RepositorySchema.optional(),
+    strictness: StrictnessSchema.optional(),
+    ai: z.string().optional(),
+    dryRun: z.boolean().default(false),
+    force: z.boolean().default(false),
+    yes: z.boolean().default(false),
+});
+//# sourceMappingURL=schema.js.map

package/dist/core/context.d.ts

@@ -0,0 +1,3 @@
+import { ResolvedWorkspaceContext, WorkspaceConfig } from '../config/schema.js';
+export declare function buildResolvedContext(config: WorkspaceConfig): ResolvedWorkspaceContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/core/context.js

@@ -0,0 +1,16 @@
+import { getAppTypeRules } from '../templates/app-types/index.js';
+import { BASE_GUARDRAILS } from '../templates/base/guardrails.js';
+import { getLanguageTemplate } from '../templates/languages/index.js';
+export function buildResolvedContext(config) {
+    const langTemplate = getLanguageTemplate(config.project.language);
+    const appRules = getAppTypeRules(config.project.type);
+    const guardrails = BASE_GUARDRAILS[config.strictness];
+    return {
+        config,
+        commands: langTemplate.commands,
+        languageRules: langTemplate.rules,
+        appTypeRules: appRules,
+        baseGuardrails: guardrails,
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/core/generator.d.ts

@@ -0,0 +1,10 @@
+import { AdapterRegistry } from '../adapters/registry.js';
+import { GeneratedFile } from '../adapters/adapter.interface.js';
+import { ResolvedWorkspaceContext } from '../config/schema.js';
+export { GeneratedFile };
+/**
+ * Pure generator function: maps ResolvedWorkspaceContext to GeneratedFile[].
+ * Does NOT execute any disk I/O, network requests, or model inferences.
+ */
+export declare function generateWorkspace(context: ResolvedWorkspaceContext, registry?: AdapterRegistry): GeneratedFile[];
+//# sourceMappingURL=generator.d.ts.map

package/dist/core/generator.js

@@ -0,0 +1,97 @@
+import { defaultRegistry } from '../adapters/registry.js';
+import { renderAiContext } from '../templates/ai-context.js';
+import { renderAiDirArchitecture } from '../templates/ai-dir/architecture.js';
+import { renderAiDirContext } from '../templates/ai-dir/context.js';
+import { renderAiDirDecisions } from '../templates/ai-dir/decisions.js';
+import { renderAiDirRules } from '../templates/ai-dir/rules.js';
+import { renderAiDirTasks } from '../templates/ai-dir/tasks.js';
+import { renderContributing } from '../templates/contributing.js';
+import { renderArchitectureDoc } from '../templates/docs/architecture-doc.js';
+import { renderDecisionsDoc } from '../templates/docs/decisions-doc.js';
+import { renderDevelopmentDoc } from '../templates/docs/development-doc.js';
+import { renderDocsReadme } from '../templates/docs/docs-readme.js';
+import { renderGitignore } from '../templates/gitignore.js';
+import { renderProjectGuardrails } from '../templates/guardrails-doc.js';
+import { renderManifest } from '../templates/manifest.js';
+import { renderProjectReadme } from '../templates/readme.js';
+/**
+ * Pure generator function: maps ResolvedWorkspaceContext to GeneratedFile[].
+ * Does NOT execute any disk I/O, network requests, or model inferences.
+ */
+export function generateWorkspace(context, registry = defaultRegistry) {
+    const files = [];
+    // 1. Canonical machine contract
+    files.push({
+        relativePath: 'ai-workspace.yaml',
+        content: renderManifest(context.config),
+    });
+    // 2. Root documentation and guardrails
+    files.push({
+        relativePath: 'README.md',
+        content: renderProjectReadme(context),
+    });
+    files.push({
+        relativePath: 'AI_CONTEXT.md',
+        content: renderAiContext(context),
+    });
+    files.push({
+        relativePath: 'PROJECT_GUARDRAILS.md',
+        content: renderProjectGuardrails(context),
+    });
+    files.push({
+        relativePath: 'CONTRIBUTING.md',
+        content: renderContributing(context),
+    });
+    files.push({
+        relativePath: '.gitignore',
+        content: renderGitignore(context.config.project.language),
+    });
+    // 3. docs/ directory structure
+    files.push({
+        relativePath: 'docs/README.md',
+        content: renderDocsReadme(context),
+    });
+    files.push({
+        relativePath: 'docs/ARCHITECTURE.md',
+        content: renderArchitectureDoc(context),
+    });
+    files.push({
+        relativePath: 'docs/DEVELOPMENT.md',
+        content: renderDevelopmentDoc(context),
+    });
+    files.push({
+        relativePath: 'docs/DECISIONS.md',
+        content: renderDecisionsDoc(context),
+    });
+    // 4. .ai/ directory structure (context, rules, architecture, decisions, tasks)
+    files.push({
+        relativePath: '.ai/context/project-context.md',
+        content: renderAiDirContext(context),
+    });
+    files.push({
+        relativePath: '.ai/rules/00-core-rules.md',
+        content: renderAiDirRules(context),
+    });
+    files.push({
+        relativePath: '.ai/architecture/system-design.md',
+        content: renderAiDirArchitecture(context),
+    });
+    files.push({
+        relativePath: '.ai/decisions/0001-project-init.md',
+        content: renderAiDirDecisions(context),
+    });
+    files.push({
+        relativePath: '.ai/tasks/task-backlog.md',
+        content: renderAiDirTasks(context),
+    });
+    // 5. Render enabled AI tool adapters
+    for (const adapterId of context.config.adapters) {
+        const adapter = registry.get(adapterId);
+        if (adapter) {
+            const adapterFiles = adapter.render(context);
+            files.push(...adapterFiles);
+        }
+    }
+    return files;
+}
+//# sourceMappingURL=generator.js.map

package/dist/core/interpolator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Pure, deterministic string substitution engine.
+ * Replaces {{KEY}} occurrences with string data values.
+ */
+export declare function interpolate(template: string, data: Record<string, string>): string;
+//# sourceMappingURL=interpolator.d.ts.map

package/dist/core/interpolator.js

@@ -0,0 +1,13 @@
+/**
+ * Pure, deterministic string substitution engine.
+ * Replaces {{KEY}} occurrences with string data values.
+ */
+export function interpolate(template, data) {
+    return template.replace(/\{\{([A-Z0-9_]+)\}\}/g, (match, key) => {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            return data[key];
+        }
+        return match;
+    });
+}
+//# sourceMappingURL=interpolator.js.map

package/dist/detection/detector.d.ts

@@ -0,0 +1,13 @@
+import { AppType, Language } from '../config/schema.js';
+export interface DetectedEnvironment {
+    readonly name: string;
+    readonly language: Language;
+    readonly type: AppType;
+    readonly isDetected: boolean;
+}
+/**
+ * Deterministically inspects target directory markers to infer project defaults.
+ * Completely decoupled from CLI prompt parsing.
+ */
+export declare function detectProjectEnvironment(targetDir: string): Promise<DetectedEnvironment>;
+//# sourceMappingURL=detector.d.ts.map