create-foundry-workspace 1.0.0

package/dist/detection/detector.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { DEFAULT_APP_TYPE, DEFAULT_LANGUAGE } from '../config/defaults.js';
+import { detectGo } from './rules/go.js';
+import { detectJava } from './rules/java.js';
+import { detectNode } from './rules/node.js';
+import { detectPython } from './rules/python.js';
+import { detectRust } from './rules/rust.js';
+/**
+ * Deterministically inspects target directory markers to infer project defaults.
+ * Completely decoupled from CLI prompt parsing.
+ */
+export async function detectProjectEnvironment(targetDir) {
+    const fallbackName = path.basename(path.resolve(targetDir)) || 'my-workspace';
+    // Run detectors in priority order
+    const node = await detectNode(targetDir);
+    if (node) {
+        return {
+            name: node.name || fallbackName,
+            language: node.language || DEFAULT_LANGUAGE,
+            type: node.type || DEFAULT_APP_TYPE,
+            isDetected: true,
+        };
+    }
+    const rust = await detectRust(targetDir);
+    if (rust) {
+        return {
+            name: rust.name || fallbackName,
+            language: 'rust',
+            type: rust.type || 'cli',
+            isDetected: true,
+        };
+    }
+    const go = await detectGo(targetDir);
+    if (go) {
+        return {
+            name: go.name || fallbackName,
+            language: 'go',
+            type: go.type || 'api',
+            isDetected: true,
+        };
+    }
+    const python = await detectPython(targetDir);
+    if (python) {
+        return {
+            name: fallbackName,
+            language: 'python',
+            type: python.type || 'api',
+            isDetected: true,
+        };
+    }
+    const java = await detectJava(targetDir);
+    if (java) {
+        return {
+            name: fallbackName,
+            language: 'java',
+            type: java.type || 'api',
+            isDetected: true,
+        };
+    }
+    return {
+        name: fallbackName,
+        language: DEFAULT_LANGUAGE,
+        type: DEFAULT_APP_TYPE,
+        isDetected: false,
+    };
+}
+//# sourceMappingURL=detector.js.map

package/dist/detection/rules/go.d.ts

@@ -0,0 +1,3 @@
+import { DetectionCandidate } from './node.js';
+export declare function detectGo(targetDir: string): Promise<DetectionCandidate | null>;
+//# sourceMappingURL=go.d.ts.map

package/dist/detection/rules/go.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectGo(targetDir) {
+    const goMod = path.join(targetDir, 'go.mod');
+    try {
+        const raw = await fs.readFile(goMod, 'utf-8');
+        const match = raw.match(/module\s+([^\s]+)/);
+        const modName = match && match[1] ? path.basename(match[1]) : undefined;
+        return {
+            name: modName,
+            language: 'go',
+            type: 'api',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=go.js.map

package/dist/detection/rules/java.d.ts

@@ -0,0 +1,3 @@
+import { DetectionCandidate } from './node.js';
+export declare function detectJava(targetDir: string): Promise<DetectionCandidate | null>;
+//# sourceMappingURL=java.d.ts.map

package/dist/detection/rules/java.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectJava(targetDir) {
+    const pomXml = path.join(targetDir, 'pom.xml');
+    const gradle = path.join(targetDir, 'build.gradle');
+    const gradleKts = path.join(targetDir, 'build.gradle.kts');
+    let hasJava = false;
+    try {
+        await fs.access(pomXml);
+        hasJava = true;
+    }
+    catch { }
+    try {
+        await fs.access(gradle);
+        hasJava = true;
+    }
+    catch { }
+    try {
+        await fs.access(gradleKts);
+        hasJava = true;
+    }
+    catch { }
+    if (!hasJava)
+        return null;
+    return {
+        language: 'java',
+        type: 'api',
+    };
+}
+//# sourceMappingURL=java.js.map

package/dist/detection/rules/node.d.ts

@@ -0,0 +1,8 @@
+import { AppType, Language } from '../../config/schema.js';
+export interface DetectionCandidate {
+    name?: string;
+    language?: Language;
+    type?: AppType;
+}
+export declare function detectNode(targetDir: string): Promise<DetectionCandidate | null>;
+//# sourceMappingURL=node.d.ts.map

package/dist/detection/rules/node.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectNode(targetDir) {
+    const pkgPath = path.join(targetDir, 'package.json');
+    try {
+        const raw = await fs.readFile(pkgPath, 'utf-8');
+        const pkg = JSON.parse(raw);
+        const name = typeof pkg.name === 'string' ? pkg.name.replace(/^@[^/]+\//, '') : undefined;
+        let language = 'javascript';
+        // Check for TypeScript markers
+        if ((pkg.devDependencies && pkg.devDependencies.typescript) ||
+            (pkg.dependencies && pkg.dependencies.typescript)) {
+            language = 'typescript';
+        }
+        try {
+            await fs.access(path.join(targetDir, 'tsconfig.json'));
+            language = 'typescript';
+        }
+        catch { }
+        let type = 'fullstack';
+        if (pkg.bin) {
+            type = 'cli';
+        }
+        else if (pkg.dependencies && (pkg.dependencies.react || pkg.dependencies.vue || pkg.dependencies.svelte)) {
+            type = 'web';
+        }
+        else if (pkg.dependencies && (pkg.dependencies.express || pkg.dependencies.fastify || pkg.dependencies.hono)) {
+            type = 'api';
+        }
+        return { name, language, type };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=node.js.map

package/dist/detection/rules/python.d.ts

@@ -0,0 +1,3 @@
+import { DetectionCandidate } from './node.js';
+export declare function detectPython(targetDir: string): Promise<DetectionCandidate | null>;
+//# sourceMappingURL=python.d.ts.map

package/dist/detection/rules/python.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectPython(targetDir) {
+    const pyproject = path.join(targetDir, 'pyproject.toml');
+    const requirements = path.join(targetDir, 'requirements.txt');
+    const setupPy = path.join(targetDir, 'setup.py');
+    let hasPython = false;
+    try {
+        await fs.access(pyproject);
+        hasPython = true;
+    }
+    catch { }
+    try {
+        await fs.access(requirements);
+        hasPython = true;
+    }
+    catch { }
+    try {
+        await fs.access(setupPy);
+        hasPython = true;
+    }
+    catch { }
+    if (!hasPython)
+        return null;
+    return {
+        language: 'python',
+        type: 'api',
+    };
+}
+//# sourceMappingURL=python.js.map

package/dist/detection/rules/rust.d.ts

@@ -0,0 +1,3 @@
+import { DetectionCandidate } from './node.js';
+export declare function detectRust(targetDir: string): Promise<DetectionCandidate | null>;
+//# sourceMappingURL=rust.d.ts.map

package/dist/detection/rules/rust.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export async function detectRust(targetDir) {
+    const cargoToml = path.join(targetDir, 'Cargo.toml');
+    try {
+        const raw = await fs.readFile(cargoToml, 'utf-8');
+        const nameMatch = raw.match(/name\s*=\s*["']([^"']+)["']/);
+        const projName = nameMatch && nameMatch[1] ? nameMatch[1] : undefined;
+        return {
+            name: projName,
+            language: 'rust',
+            type: 'cli',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=rust.js.map

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './config/schema.js';
+export * from './config/defaults.js';
+export * from './detection/detector.js';
+export * from './adapters/adapter.interface.js';
+export * from './adapters/registry.js';
+export * from './core/context.js';
+export * from './core/generator.js';
+export * from './core/interpolator.js';
+export * from './io/paths.js';
+export * from './io/writer.js';
+export * from './cli/command.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from './config/schema.js';
+export * from './config/defaults.js';
+export * from './detection/detector.js';
+export * from './adapters/adapter.interface.js';
+export * from './adapters/registry.js';
+export * from './core/context.js';
+export * from './core/generator.js';
+export * from './core/interpolator.js';
+export * from './io/paths.js';
+export * from './io/writer.js';
+export * from './cli/command.js';
+//# sourceMappingURL=index.js.map

package/dist/io/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Normalizes relative paths to POSIX format (forward slashes).
+ * Ensures cross-platform consistency across Windows, macOS, and Linux.
+ */
+export declare function normalizeRelativePath(filePath: string): string;
+/**
+ * Safely resolves target file path within target directory.
+ * Throws an error if target path traverses outside target directory.
+ */
+export declare function resolveSafePath(baseDir: string, relativePath: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/io/paths.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+/**
+ * Normalizes relative paths to POSIX format (forward slashes).
+ * Ensures cross-platform consistency across Windows, macOS, and Linux.
+ */
+export function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join('/');
+}
+/**
+ * Safely resolves target file path within target directory.
+ * Throws an error if target path traverses outside target directory.
+ */
+export function resolveSafePath(baseDir, relativePath) {
+    const resolvedBase = path.resolve(baseDir);
+    const resolvedTarget = path.resolve(resolvedBase, relativePath);
+    if (!resolvedTarget.startsWith(resolvedBase)) {
+        throw new Error(`Security Exception: Target path '${relativePath}' traverses outside base directory.`);
+    }
+    return resolvedTarget;
+}
+//# sourceMappingURL=paths.js.map

package/dist/io/writer.d.ts

@@ -0,0 +1,23 @@
+import { GeneratedFile } from '../adapters/adapter.interface.js';
+export interface WriteOptions {
+    dryRun?: boolean;
+    force?: boolean;
+    abortOnCollision?: boolean;
+}
+export interface WriteResult {
+    files: GeneratedFile[];
+    written: string[];
+    skipped: string[];
+    collisions: string[];
+    dryRun: boolean;
+}
+/**
+ * Checks for existing files in target directory.
+ */
+export declare function detectCollisions(targetDir: string, files: GeneratedFile[]): Promise<string[]>;
+/**
+ * The ONLY function in the codebase permitted to perform filesystem writes.
+ * Implements safe-merge, force overwrite, dry-run, and collision handling.
+ */
+export declare function writeWorkspace(targetDir: string, files: GeneratedFile[], options?: WriteOptions): Promise<WriteResult>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/io/writer.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeRelativePath, resolveSafePath } from './paths.js';
+/**
+ * Checks for existing files in target directory.
+ */
+export async function detectCollisions(targetDir, files) {
+    const collisions = [];
+    for (const file of files) {
+        const fullPath = resolveSafePath(targetDir, file.relativePath);
+        try {
+            await fs.access(fullPath);
+            collisions.push(normalizeRelativePath(file.relativePath));
+        }
+        catch {
+            // File does not exist, no collision
+        }
+    }
+    return collisions;
+}
+/**
+ * The ONLY function in the codebase permitted to perform filesystem writes.
+ * Implements safe-merge, force overwrite, dry-run, and collision handling.
+ */
+export async function writeWorkspace(targetDir, files, options = {}) {
+    const { dryRun = false, force = false, abortOnCollision = false } = options;
+    const collisions = await detectCollisions(targetDir, files);
+    if (collisions.length > 0 && abortOnCollision && !force) {
+        throw new Error(`Aborted: Found ${collisions.length} existing files in '${targetDir}'. Use --force to overwrite.`);
+    }
+    const written = [];
+    const skipped = [];
+    for (const file of files) {
+        const normPath = normalizeRelativePath(file.relativePath);
+        const fullPath = resolveSafePath(targetDir, file.relativePath);
+        const isCollision = collisions.includes(normPath);
+        if (isCollision && !force) {
+            skipped.push(normPath);
+            continue;
+        }
+        if (!dryRun) {
+            const parentDir = path.dirname(fullPath);
+            await fs.mkdir(parentDir, { recursive: true });
+            await fs.writeFile(fullPath, file.content, 'utf-8');
+        }
+        written.push(normPath);
+    }
+    return {
+        files,
+        written,
+        skipped,
+        collisions,
+        dryRun,
+    };
+}
+//# sourceMappingURL=writer.js.map

package/dist/templates/agents.d.ts

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

package/dist/templates/agents.js

@@ -0,0 +1,41 @@
+export function renderAgentsDocument(context) {
+    const { config, commands, languageRules, appTypeRules, baseGuardrails } = context;
+    return `# ${config.project.name} — AI Development Contract (AGENTS.md)
+
+Welcome to **${config.project.name}**. This file defines the core context, commands, and non-negotiable architectural boundaries for human engineers and AI coding assistants collaborating on this project.
+
+---
+
+## 1. Application Profile & Scope
+- **Project Name:** ${config.project.name}
+- **Application Type:** ${config.project.type}
+- **Primary Language:** ${config.project.language}
+- **Strictness Level:** ${config.strictness}
+
+---
+
+## 2. Standard Development Commands
+- **Build:** \`${commands.build}\`
+- **Test:** \`${commands.test}\`
+- **Development Server / Entry:** \`${commands.dev}\`
+- **Lint / Static Analysis:** \`${commands.lint}\`
+
+Always run and verify tests and linting before marking tasks or issues as resolved.
+
+---
+
+## 3. Project Architecture & Standards
+${appTypeRules}
+
+---
+
+## 4. Language & Code Style Conventions
+${languageRules}
+
+---
+
+## 5. Architectural Guardrails
+${baseGuardrails}
+`;
+}
+//# sourceMappingURL=agents.js.map

package/dist/templates/ai-context.d.ts

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

package/dist/templates/ai-context.js

@@ -0,0 +1,28 @@
+export function renderAiContext(context) {
+    const { config, commands } = context;
+    return `# AI Context — ${config.project.name}
+
+> High-priority system context for LLMs, coding agents, and developers.
+
+## Project Summary
+- **Name:** ${config.project.name}
+- **Type:** ${config.project.type}
+- **Language:** ${config.project.language}
+- **Repository:** ${config.repository}
+- **Strictness:** ${config.strictness}
+
+## Critical Commands
+- Build: \`${commands.build}\`
+- Test:  \`${commands.test}\`
+- Dev:   \`${commands.dev}\`
+- Lint:  \`${commands.lint}\`
+
+## Context Map
+- Canonical rules: \`.ai/rules/00-core-rules.md\`
+- Architecture: \`.ai/architecture/system-design.md\` and \`docs/ARCHITECTURE.md\`
+- Decisions: \`.ai/decisions/\` and \`docs/DECISIONS.md\`
+- Task tracking: \`.ai/tasks/task-backlog.md\`
+- Guardrails: \`PROJECT_GUARDRAILS.md\`
+`;
+}
+//# sourceMappingURL=ai-context.js.map

package/dist/templates/ai-dir/architecture.d.ts

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

package/dist/templates/ai-dir/architecture.js

@@ -0,0 +1,13 @@
+export function renderAiDirArchitecture(context) {
+    const { config, appTypeRules } = context;
+    return `# AI Architecture Overview — ${config.project.name}
+
+## Application Classification: ${config.project.type}
+
+${appTypeRules}
+
+## System Boundaries
+AI coding assistants should consult this file before creating new modules, services, or structural changes to verify they fit within the planned architecture.
+`;
+}
+//# sourceMappingURL=architecture.js.map

package/dist/templates/ai-dir/context.d.ts

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

package/dist/templates/ai-dir/context.js

@@ -0,0 +1,14 @@
+export function renderAiDirContext(context) {
+    const { config } = context;
+    return `# Project Context — ${config.project.name}
+
+## 1. Domain & Purpose
+- Project: ${config.project.name}
+- Type: ${config.project.type}
+- Language: ${config.project.language}
+
+## 2. Key Concepts & Terminology
+Document project-specific business concepts and domain models here so that AI assistants maintain consistent naming conventions across files.
+`;
+}
+//# sourceMappingURL=context.js.map

package/dist/templates/ai-dir/decisions.d.ts

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

package/dist/templates/ai-dir/decisions.js

@@ -0,0 +1,21 @@
+export function renderAiDirDecisions(context) {
+    const { config } = context;
+    return `# ADR 0001: Initial AI Workspace Setup
+
+- **Status:** Accepted
+- **Deciders:** Project Author / Foundry Scaffolding Tool
+
+## Context
+A new software development workspace is being initialized. To ensure consistent collaboration between human developers and AI assistants (Cursor, Claude Code, Copilot, etc.), an unambiguous workspace contract is required.
+
+## Decision
+1. Initialized workspace with application type \`${config.project.type}\` and language \`${config.project.language}\`.
+2. Established strictness level at \`${config.strictness}\`.
+3. Configured AI workflows: ${config.adapters.join(', ')}.
+
+## Consequences
+- AI assistants will follow canonical project guidelines in \`.ai/\` and \`AGENTS.md\`.
+- All architectural decisions must be recorded as ADRs in this directory.
+`;
+}
+//# sourceMappingURL=decisions.js.map

package/dist/templates/ai-dir/rules.d.ts

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

package/dist/templates/ai-dir/rules.js

@@ -0,0 +1,12 @@
+export function renderAiDirRules(context) {
+    const { config, baseGuardrails, languageRules } = context;
+    return `# Core Workspace Rules — ${config.project.name}
+
+## Strictness Level: ${config.strictness}
+
+${baseGuardrails}
+
+${languageRules}
+`;
+}
+//# sourceMappingURL=rules.js.map

package/dist/templates/ai-dir/tasks.d.ts

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

package/dist/templates/ai-dir/tasks.js

@@ -0,0 +1,31 @@
+export function renderAiDirTasks(context) {
+    const { config } = context;
+    return `# AI Task Tracking — ${config.project.name}
+
+Operational scratchpad for human engineers and AI coding assistants to queue, claim, verify, and complete discrete engineering tasks.
+
+---
+
+## Agent Task Execution Protocol
+1. **Claiming:** Before executing non-trivial edits, move or record the task under **Active Task (WIP)** with a brief implementation plan.
+2. **Verification:** Never move an item to **Completed Tasks** until all automated test suites, linting, and typechecks pass with zero errors.
+3. **Traceability:** Document significant architectural decisions in \`.ai/decisions/\`.
+
+---
+
+## Active Task (WIP)
+<!-- Record the currently active task, planned steps, and validation checklist here -->
+*(No active task. Select or add a task from the backlog before beginning work.)*
+
+---
+
+## Task Backlog
+<!-- Queue upcoming features, enhancements, refactors, or bugfixes below -->
+
+---
+
+## Completed Tasks
+- [x] Initialized AI Workspace via Foundry (\`create-foundry-workspace\`)
+`;
+}
+//# sourceMappingURL=tasks.js.map

package/dist/templates/app-types/api.d.ts

@@ -0,0 +1,2 @@
+export declare const apiRules = "### Backend API Architecture\n- Structure endpoints logically with strict request payload validation and response schemas.\n- Isolate business logic in domain services; keep controller/handler functions thin.\n- Implement centralized error handling, structured logging, and robust authentication middleware.";
+//# sourceMappingURL=api.d.ts.map

package/dist/templates/app-types/api.js

@@ -0,0 +1,5 @@
+export const apiRules = `### Backend API Architecture
+- Structure endpoints logically with strict request payload validation and response schemas.
+- Isolate business logic in domain services; keep controller/handler functions thin.
+- Implement centralized error handling, structured logging, and robust authentication middleware.`;
+//# sourceMappingURL=api.js.map

package/dist/templates/app-types/cli.d.ts

@@ -0,0 +1,2 @@
+export declare const cliRules = "### CLI Tool Architecture\n- Provide intuitive argument and flag parsing with comprehensive `--help` menus.\n- Support both interactive terminal prompts and non-interactive scripted/CI execution modes.\n- Implement structured exit codes and send human messages to stdout and diagnostics to stderr.";
+//# sourceMappingURL=cli.d.ts.map

package/dist/templates/app-types/cli.js

@@ -0,0 +1,5 @@
+export const cliRules = `### CLI Tool Architecture
+- Provide intuitive argument and flag parsing with comprehensive \`--help\` menus.
+- Support both interactive terminal prompts and non-interactive scripted/CI execution modes.
+- Implement structured exit codes and send human messages to stdout and diagnostics to stderr.`;
+//# sourceMappingURL=cli.js.map

package/dist/templates/app-types/data-ml.d.ts

@@ -0,0 +1,2 @@
+export declare const dataMlRules = "### Data & Machine Learning Architecture\n- Separate raw data ingestion, preprocessing pipelines, and model training/inference scripts.\n- Track model artifacts, dataset schemas, and hyperparameter configurations deterministically.\n- Implement automated validation checks for input tensor dimensions and data distribution shifts.";
+//# sourceMappingURL=data-ml.d.ts.map

package/dist/templates/app-types/data-ml.js

@@ -0,0 +1,5 @@
+export const dataMlRules = `### Data & Machine Learning Architecture
+- Separate raw data ingestion, preprocessing pipelines, and model training/inference scripts.
+- Track model artifacts, dataset schemas, and hyperparameter configurations deterministically.
+- Implement automated validation checks for input tensor dimensions and data distribution shifts.`;
+//# sourceMappingURL=data-ml.js.map

package/dist/templates/app-types/fullstack.d.ts

@@ -0,0 +1,2 @@
+export declare const fullstackRules = "### Full-Stack Architecture\n- Enforce clean separation between client-side presentation and server-side domain logic.\n- Share data contracts or type definitions across client and server boundaries to eliminate schema drift.\n- Ensure all mutation operations are fully validated on the server regardless of client validation.";
+//# sourceMappingURL=fullstack.d.ts.map

package/dist/templates/app-types/fullstack.js

@@ -0,0 +1,5 @@
+export const fullstackRules = `### Full-Stack Architecture
+- Enforce clean separation between client-side presentation and server-side domain logic.
+- Share data contracts or type definitions across client and server boundaries to eliminate schema drift.
+- Ensure all mutation operations are fully validated on the server regardless of client validation.`;
+//# sourceMappingURL=fullstack.js.map

package/dist/templates/app-types/index.d.ts

@@ -0,0 +1,3 @@
+import { AppType } from '../../config/schema.js';
+export declare function getAppTypeRules(type: AppType): string;
+//# sourceMappingURL=index.d.ts.map