@savvy-web/templates 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Savvy Web Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# @savvy-web/templates
+
+[![npm version](https://img.shields.io/npm/v/@savvy-web/templates)](https://www.npmjs.com/package/@savvy-web/templates)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Pure TypeScript templates for Silk Suite project scaffolding. Each template takes typed options (validated with [Effect](https://effect.website/) Schema) and returns `TemplateEntry[]` -- a list of `{ name, filename, content }` records. No filesystem calls; you decide where and how to write the output.
+
+## Features
+
+- Generate config files for package.json, tsconfig, Biome, Turborepo, pnpm, changesets, VS Code, gitignore, and README
+- Validate all inputs at runtime with Effect Schema
+- Compose an entire workspace scaffold from a single `createWorkspace` call
+- Zero side effects -- templates return plain strings, never touch disk
+
+## Installation
+
+```bash
+pnpm add @savvy-web/templates effect
+```
+
+`effect` is a peer dependency.
+
+## Quick Start
+
+```typescript
+import { createPackageJson } from "@savvy-web/templates";
+
+const entries = createPackageJson({
+  name: "@my-org/my-lib",
+  description: "A useful library",
+  type: "module",
+  license: "MIT",
+  exports: { ".": "./src/index.ts" },
+});
+
+for (const entry of entries) {
+  console.log(entry.filename); // "package.json"
+  console.log(entry.content);  // sorted, formatted JSON
+}
+```
+
+## API
+
+Every `create*` function accepts an options object (or `unknown` -- Schema validates at runtime) and returns `TemplateEntry[]`.
+
+### TemplateEntry
+
+```typescript
+interface TemplateEntry {
+  readonly name: string;     // logical name, e.g. "tsconfig"
+  readonly filename: string; // suggested path, e.g. "tsconfig.json"
+  readonly content: string;  // generated file content
+}
+```
+
+### Templates
+
+| Function | Output file | Key options |
+| --- | --- | --- |
+| `createPackageJson` | `package.json` | `name`, `version`, `type`, `exports`, `scripts`, `dependencies`, `engines`, `publishConfig` |
+| `createTsConfig` | `tsconfig.json` | `extends`, `composite`, `include`, `exclude`, `references` |
+| `createBiome` | `biome.jsonc` | `version`, `extends`, `root` |
+| `createTurboRoot` | `turbo.json` | `tasks`, `globalDependencies`, `globalEnv`, `ui`, `concurrency` |
+| `createTurboWorkspace` | `turbo.json` | `tasks` (extends root with `["//"]`) |
+| `createPnpmWorkspace` | `pnpm-workspace.yaml` | `packages`, `autoInstallPeers`, `catalogMode`, `catalog` |
+| `createChangeset` | `.changeset/config.json` | `access`, `baseBranch`, `changelog`, `repo` |
+| `createVsCode` | `.vscode/settings.json`, `.vscode/extensions.json` | `settings` (`biome`, `turbo`, `vitest`), `extensions` |
+| `createGitignore` | `.gitignore` | `sections` (`node`, `build`, `env`, `os`, `silk`), `additional` |
+| `createReadme` | `README.md` | `name`, `description` |
+
+### Workspace Compositor
+
+`createWorkspace` composes multiple templates into a full monorepo scaffold:
+
+```typescript
+import { createWorkspace } from "@savvy-web/templates";
+
+const entries = createWorkspace({
+  name: "my-monorepo",
+  packageManager: "pnpm",
+  packageManagerVersion: "10.33.0",
+  nodeVersion: "24.11.0",
+  features: {
+    biome: true,
+    turbo: true,
+    changesets: true,
+    vscode: true,
+    vitest: true,
+  },
+});
+
+// entries contains: package.json, tsconfig.json, .gitignore, README.md,
+// pnpm-workspace.yaml, biome.jsonc, turbo.json, .changeset/config.json,
+// .vscode/settings.json, .vscode/extensions.json
+```
+
+Each feature flag is optional and defaults to `false`. The compositor always generates package.json, tsconfig.json, .gitignore, and README.md. pnpm-workspace.yaml is added automatically when `packageManager` is `"pnpm"`.
+
+## License
+
+[MIT](./LICENSE)

package/index.d.ts

@@ -0,0 +1,203 @@
+import { Schema } from 'effect';
+
+export declare const BiomeOptions: Schema.Struct<{
+    version: typeof Schema.String;
+    extends: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    root: Schema.optional<typeof Schema.Boolean>;
+}>;
+
+export declare type BiomeOptionsType = typeof BiomeOptions.Type;
+
+export declare const ChangesetOptions: Schema.Struct<{
+    access: Schema.optionalWith<Schema.Literal<["public", "restricted"]>, {
+        default: () => "restricted";
+    }>;
+    baseBranch: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    changelog: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    repo: Schema.optional<Schema.filter<typeof Schema.String>>;
+}>;
+
+export declare type ChangesetOptionsType = typeof ChangesetOptions.Type;
+
+export declare function createBiome(options: unknown): TemplateEntry[];
+
+export declare function createChangeset(options: unknown): TemplateEntry[];
+
+export declare function createGitignore(options: unknown): TemplateEntry[];
+
+export declare function createPackageJson(options: unknown): TemplateEntry[];
+
+export declare function createPnpmWorkspace(options: unknown): TemplateEntry[];
+
+export declare function createReadme(options: unknown): TemplateEntry[];
+
+export declare function createTsConfig(options: unknown): TemplateEntry[];
+
+export declare function createTurboRoot(options: unknown): TemplateEntry[];
+
+export declare function createTurboWorkspace(options: unknown): TemplateEntry[];
+
+export declare function createVsCode(options: unknown): TemplateEntry[];
+
+export declare function createWorkspace(options: unknown): TemplateEntry[];
+
+export declare const GitignoreOptions: Schema.Struct<{
+    sections: Schema.optional<Schema.Struct<{
+        node: Schema.optional<typeof Schema.Boolean>;
+        build: Schema.optional<typeof Schema.Boolean>;
+        env: Schema.optional<typeof Schema.Boolean>;
+        os: Schema.optional<typeof Schema.Boolean>;
+        silk: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    additional: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+
+export declare type GitignoreOptionsType = typeof GitignoreOptions.Type;
+
+export declare const PackageJsonOptions: Schema.Struct<{
+    name: typeof Schema.String;
+    version: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    private: Schema.optional<typeof Schema.Boolean>;
+    description: Schema.optional<typeof Schema.String>;
+    homepage: Schema.optional<typeof Schema.String>;
+    bugs: Schema.optional<Schema.Struct<{
+        url: typeof Schema.String;
+    }>>;
+    repository: Schema.optional<Schema.Struct<{
+        type: typeof Schema.String;
+        url: typeof Schema.String;
+        directory: Schema.optional<typeof Schema.String>;
+    }>>;
+    license: Schema.optional<typeof Schema.String>;
+    author: Schema.optional<Schema.Struct<{
+        name: typeof Schema.String;
+        email: Schema.optional<typeof Schema.String>;
+        url: Schema.optional<typeof Schema.String>;
+    }>>;
+    sideEffects: Schema.optional<typeof Schema.Boolean>;
+    type: Schema.optional<Schema.Literal<["module", "commonjs"]>>;
+    exports: Schema.optional<typeof Schema.Unknown>;
+    scripts: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    dependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    devDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    peerDependencies: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    engines: Schema.optional<Schema.Struct<{
+        node: Schema.optional<typeof Schema.String>;
+        pnpm: Schema.optional<typeof Schema.String>;
+    }>>;
+    packageManager: Schema.optional<typeof Schema.String>;
+    devEngines: Schema.optional<typeof Schema.Unknown>;
+    publishConfig: Schema.optional<Schema.Struct<{
+        access: Schema.optional<typeof Schema.String>;
+        directory: Schema.optional<typeof Schema.String>;
+        linkDirectory: Schema.optional<typeof Schema.Boolean>;
+        targets: Schema.optional<typeof Schema.Unknown>;
+    }>>;
+    keywords: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+
+export declare type PackageJsonOptionsType = typeof PackageJsonOptions.Type;
+
+export declare const PnpmWorkspaceOptions: Schema.Struct<{
+    packages: Schema.Array$<typeof Schema.String>;
+    autoInstallPeers: Schema.optional<typeof Schema.Boolean>;
+    catalogMode: Schema.optional<Schema.Literal<["strict", "prefer", "manual"]>>;
+    catalog: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>;
+
+export declare type PnpmWorkspaceOptionsType = typeof PnpmWorkspaceOptions.Type;
+
+export declare const ReadmeOptions: Schema.Struct<{
+    name: typeof Schema.String;
+    description: Schema.optional<typeof Schema.String>;
+}>;
+
+export declare type ReadmeOptionsType = typeof ReadmeOptions.Type;
+
+/** A template: typed options in, content entries out. */
+export declare type Template<O> = (options: O) => TemplateEntry[];
+
+/**
+ * A generated content entry from a template.
+ *
+ * Templates produce content with a logical name and suggested filename.
+ * The consumer decides where (and whether) to write the content.
+ */
+export declare interface TemplateEntry {
+    /** Logical name for this entry (e.g., "tsconfig", "biome", "vscode-settings") */
+    readonly name: string;
+    /** Suggested default filename (e.g., "tsconfig.json", ".vscode/settings.json") */
+    readonly filename: string;
+    /** The generated file content */
+    readonly content: string;
+}
+
+export declare const TsConfigOptions: Schema.Struct<{
+    extends: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.String>]>>;
+    composite: Schema.optional<typeof Schema.Boolean>;
+    include: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    exclude: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    references: Schema.optional<Schema.Array$<Schema.Struct<{
+        path: typeof Schema.String;
+    }>>>;
+}>;
+
+export declare type TsConfigOptionsType = typeof TsConfigOptions.Type;
+
+export declare const TurboRootOptions: Schema.Struct<{
+    tasks: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    globalDependencies: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    globalEnv: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    globalPassThroughEnv: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    ui: Schema.optional<Schema.Literal<["tui", "stream"]>>;
+    concurrency: Schema.optional<Schema.Union<[typeof Schema.String, typeof Schema.Number]>>;
+}>;
+
+export declare type TurboRootOptionsType = typeof TurboRootOptions.Type;
+
+export declare const TurboWorkspaceOptions: Schema.Struct<{
+    tasks: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+
+export declare type TurboWorkspaceOptionsType = typeof TurboWorkspaceOptions.Type;
+
+/** An update template: existing content + partial options in, content entries out. */
+export declare type UpdateTemplate<O> = (existing: string, options: Partial<O>) => TemplateEntry[];
+
+export declare const VsCodeOptions: Schema.Struct<{
+    settings: Schema.optional<Schema.Struct<{
+        biome: Schema.optional<typeof Schema.Boolean>;
+        turbo: Schema.optional<typeof Schema.Boolean>;
+        vitest: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+    extensions: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+
+export declare type VsCodeOptionsType = typeof VsCodeOptions.Type;
+
+export declare const WorkspaceOptions: Schema.Struct<{
+    name: typeof Schema.String;
+    packageManager: Schema.Literal<["pnpm", "npm", "bun"]>;
+    packageManagerVersion: typeof Schema.String;
+    nodeVersion: typeof Schema.String;
+    biomeVersion: Schema.optionalWith<typeof Schema.String, {
+        default: () => string;
+    }>;
+    features: Schema.optional<Schema.Struct<{
+        biome: Schema.optional<typeof Schema.Boolean>;
+        vitest: Schema.optional<typeof Schema.Boolean>;
+        turbo: Schema.optional<typeof Schema.Boolean>;
+        changesets: Schema.optional<typeof Schema.Boolean>;
+        vscode: Schema.optional<typeof Schema.Boolean>;
+    }>>;
+}>;
+
+export declare type WorkspaceOptionsType = typeof WorkspaceOptions.Type;
+
+export { }

package/index.js

@@ -0,0 +1,491 @@
+import { Schema } from "effect";
+import { sortPackageJson } from "sort-package-json";
+import js_yaml from "js-yaml";
+const BiomeOptions = Schema.Struct({
+    version: Schema.String,
+    extends: Schema.optional(Schema.Array(Schema.String)),
+    root: Schema.optional(Schema.Boolean)
+});
+function createBiome(options) {
+    const opts = Schema.decodeUnknownSync(BiomeOptions)(options);
+    const config = {
+        $schema: `https://biomejs.dev/schemas/${opts.version}/schema.json`
+    };
+    if (opts.extends && opts.extends.length > 0) config.extends = opts.extends;
+    if (void 0 !== opts.root) config.root = opts.root;
+    const content = JSON.stringify(config, null, "\t");
+    return [
+        {
+            name: "biome",
+            filename: "biome.jsonc",
+            content
+        }
+    ];
+}
+const RepoPattern = Schema.String.pipe(Schema.pattern(/^[^/\s]+\/[^/\s]+$/));
+const ChangesetOptions = Schema.Struct({
+    access: Schema.optionalWith(Schema.Literal("public", "restricted"), {
+        default: ()=>"restricted"
+    }),
+    baseBranch: Schema.optionalWith(Schema.String, {
+        default: ()=>"main"
+    }),
+    changelog: Schema.optionalWith(Schema.String, {
+        default: ()=>"@savvy-web/changesets/changelog"
+    }),
+    repo: Schema.optional(RepoPattern)
+});
+function createChangeset(options) {
+    const opts = Schema.decodeUnknownSync(ChangesetOptions)(options);
+    const config = {
+        $schema: "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+        changelog: opts.repo ? [
+            opts.changelog,
+            {
+                repo: opts.repo
+            }
+        ] : opts.changelog,
+        commit: false,
+        fixed: [],
+        linked: [],
+        access: opts.access,
+        baseBranch: opts.baseBranch,
+        updateInternalDependencies: "patch",
+        privatePackages: {
+            version: true,
+            tag: false
+        },
+        ignore: []
+    };
+    const content = JSON.stringify(config, null, "\t");
+    return [
+        {
+            name: "changeset",
+            filename: ".changeset/config.json",
+            content
+        }
+    ];
+}
+const GitignoreOptions = Schema.Struct({
+    sections: Schema.optional(Schema.Struct({
+        node: Schema.optional(Schema.Boolean),
+        build: Schema.optional(Schema.Boolean),
+        env: Schema.optional(Schema.Boolean),
+        os: Schema.optional(Schema.Boolean),
+        silk: Schema.optional(Schema.Boolean)
+    })),
+    additional: Schema.optional(Schema.Array(Schema.String))
+});
+function createGitignore(options) {
+    const opts = Schema.decodeUnknownSync(GitignoreOptions)(options);
+    const sections = {
+        node: opts.sections?.node ?? true,
+        build: opts.sections?.build ?? true,
+        env: opts.sections?.env ?? true,
+        os: opts.sections?.os ?? true,
+        silk: opts.sections?.silk ?? true
+    };
+    const lines = [];
+    if (sections.os) lines.push("# OS files", "**/.DS_Store", "");
+    if (sections.node) lines.push("# Node.js", "**/node_modules", "**/*.tsbuildinfo*", "");
+    if (sections.build) lines.push("# Build artifacts", "**/dist", "**/.rslib", "**/.turbo", "**/*.api.json", "", "# Test artifacts", "**/.coverage", "**/.vitest", "");
+    if (sections.silk) lines.push("# Release artifacts", "pnpm-publish-summary.json", "pnpm-release.json", ".changeset/status.json", "", "# Private keys", "**/*.asc", "", "# AI agent settings", ".mcp.json", "");
+    if (sections.env) lines.push("# Environment files", "**/.env", "**/.env.*", "");
+    if (opts.additional && opts.additional.length > 0) lines.push("# Additional", ...opts.additional, "");
+    const content = lines.join("\n");
+    return [
+        {
+            name: "gitignore",
+            filename: ".gitignore",
+            content
+        }
+    ];
+}
+const Author = Schema.Struct({
+    name: Schema.String,
+    email: Schema.optional(Schema.String),
+    url: Schema.optional(Schema.String)
+});
+const Bugs = Schema.Struct({
+    url: Schema.String
+});
+const Repository = Schema.Struct({
+    type: Schema.String,
+    url: Schema.String,
+    directory: Schema.optional(Schema.String)
+});
+const PublishConfig = Schema.Struct({
+    access: Schema.optional(Schema.String),
+    directory: Schema.optional(Schema.String),
+    linkDirectory: Schema.optional(Schema.Boolean),
+    targets: Schema.optional(Schema.Unknown)
+});
+const PackageJsonOptions = Schema.Struct({
+    name: Schema.String,
+    version: Schema.optionalWith(Schema.String, {
+        default: ()=>"0.0.0"
+    }),
+    private: Schema.optional(Schema.Boolean),
+    description: Schema.optional(Schema.String),
+    homepage: Schema.optional(Schema.String),
+    bugs: Schema.optional(Bugs),
+    repository: Schema.optional(Repository),
+    license: Schema.optional(Schema.String),
+    author: Schema.optional(Author),
+    sideEffects: Schema.optional(Schema.Boolean),
+    type: Schema.optional(Schema.Literal("module", "commonjs")),
+    exports: Schema.optional(Schema.Unknown),
+    scripts: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    dependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    devDependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    peerDependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    engines: Schema.optional(Schema.Struct({
+        node: Schema.optional(Schema.String),
+        pnpm: Schema.optional(Schema.String)
+    })),
+    packageManager: Schema.optional(Schema.String),
+    devEngines: Schema.optional(Schema.Unknown),
+    publishConfig: Schema.optional(PublishConfig),
+    keywords: Schema.optional(Schema.Array(Schema.String))
+});
+function createPackageJson(options) {
+    const opts = Schema.decodeUnknownSync(PackageJsonOptions)(options);
+    const pkg = {
+        name: opts.name,
+        version: opts.version
+    };
+    if (void 0 !== opts.private) pkg.private = opts.private;
+    if (opts.description) pkg.description = opts.description;
+    if (opts.homepage) pkg.homepage = opts.homepage;
+    if (opts.bugs) pkg.bugs = opts.bugs;
+    if (opts.repository) pkg.repository = opts.repository;
+    if (opts.license) pkg.license = opts.license;
+    if (opts.author) pkg.author = opts.author;
+    if (void 0 !== opts.sideEffects) pkg.sideEffects = opts.sideEffects;
+    if (opts.type) pkg.type = opts.type;
+    if (opts.exports) pkg.exports = opts.exports;
+    if (opts.scripts && Object.keys(opts.scripts).length > 0) pkg.scripts = opts.scripts;
+    if (opts.dependencies && Object.keys(opts.dependencies).length > 0) pkg.dependencies = opts.dependencies;
+    if (opts.devDependencies && Object.keys(opts.devDependencies).length > 0) pkg.devDependencies = opts.devDependencies;
+    if (opts.peerDependencies && Object.keys(opts.peerDependencies).length > 0) pkg.peerDependencies = opts.peerDependencies;
+    if (opts.engines) pkg.engines = opts.engines;
+    if (opts.packageManager) pkg.packageManager = opts.packageManager;
+    if (opts.devEngines) pkg.devEngines = opts.devEngines;
+    if (opts.publishConfig) pkg.publishConfig = opts.publishConfig;
+    if (opts.keywords && opts.keywords.length > 0) pkg.keywords = opts.keywords;
+    const sorted = sortPackageJson(pkg);
+    const content = JSON.stringify(sorted, null, "\t");
+    return [
+        {
+            name: "package-json",
+            filename: "package.json",
+            content
+        }
+    ];
+}
+const PnpmWorkspaceOptions = Schema.Struct({
+    packages: Schema.Array(Schema.String),
+    autoInstallPeers: Schema.optional(Schema.Boolean),
+    catalogMode: Schema.optional(Schema.Literal("strict", "prefer", "manual")),
+    catalog: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    }))
+});
+function createPnpmWorkspace(options) {
+    const opts = Schema.decodeUnknownSync(PnpmWorkspaceOptions)(options);
+    const config = {
+        packages: opts.packages
+    };
+    if (void 0 !== opts.autoInstallPeers) config.autoInstallPeers = opts.autoInstallPeers;
+    if (opts.catalogMode) config.catalogMode = opts.catalogMode;
+    if (opts.catalog && Object.keys(opts.catalog).length > 0) config.catalog = opts.catalog;
+    const content = js_yaml.dump(config, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        sortKeys: false
+    });
+    return [
+        {
+            name: "pnpm-workspace",
+            filename: "pnpm-workspace.yaml",
+            content
+        }
+    ];
+}
+const ReadmeOptions = Schema.Struct({
+    name: Schema.String,
+    description: Schema.optional(Schema.String)
+});
+function createReadme(options) {
+    const opts = Schema.decodeUnknownSync(ReadmeOptions)(options);
+    const lines = [
+        `# ${opts.name}`
+    ];
+    if (opts.description) lines.push("", opts.description);
+    lines.push("");
+    const content = lines.join("\n");
+    return [
+        {
+            name: "readme",
+            filename: "README.md",
+            content
+        }
+    ];
+}
+const TsConfigOptions = Schema.Struct({
+    extends: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.String))),
+    composite: Schema.optional(Schema.Boolean),
+    include: Schema.optional(Schema.Array(Schema.String)),
+    exclude: Schema.optional(Schema.Array(Schema.String)),
+    references: Schema.optional(Schema.Array(Schema.Struct({
+        path: Schema.String
+    })))
+});
+function createTsConfig(options) {
+    const opts = Schema.decodeUnknownSync(TsConfigOptions)(options);
+    const config = {};
+    if (void 0 !== opts.extends) config.extends = "string" == typeof opts.extends ? [
+        opts.extends
+    ] : opts.extends;
+    if (void 0 !== opts.composite) config.composite = opts.composite;
+    if (opts.include) config.include = opts.include;
+    if (opts.exclude) config.exclude = opts.exclude;
+    if (opts.references) config.references = opts.references;
+    const content = JSON.stringify(config, null, "\t");
+    return [
+        {
+            name: "tsconfig",
+            filename: "tsconfig.json",
+            content
+        }
+    ];
+}
+const TurboRootOptions = Schema.Struct({
+    tasks: Schema.Record({
+        key: Schema.String,
+        value: Schema.Unknown
+    }),
+    globalDependencies: Schema.optional(Schema.Array(Schema.String)),
+    globalEnv: Schema.optional(Schema.Array(Schema.String)),
+    globalPassThroughEnv: Schema.optional(Schema.Array(Schema.String)),
+    ui: Schema.optional(Schema.Literal("tui", "stream")),
+    concurrency: Schema.optional(Schema.Union(Schema.String, Schema.Number))
+});
+const TurboWorkspaceOptions = Schema.Struct({
+    tasks: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.Unknown
+    }))
+});
+function createTurboRoot(options) {
+    const opts = Schema.decodeUnknownSync(TurboRootOptions)(options);
+    const config = {
+        $schema: "https://turborepo.com/schema.v2.json",
+        tasks: opts.tasks
+    };
+    if (opts.globalDependencies && opts.globalDependencies.length > 0) config.globalDependencies = opts.globalDependencies;
+    if (opts.globalEnv && opts.globalEnv.length > 0) config.globalEnv = opts.globalEnv;
+    if (opts.globalPassThroughEnv && opts.globalPassThroughEnv.length > 0) config.globalPassThroughEnv = opts.globalPassThroughEnv;
+    if (opts.ui) config.ui = opts.ui;
+    if (void 0 !== opts.concurrency) config.concurrency = opts.concurrency;
+    const content = JSON.stringify(config, null, "\t");
+    return [
+        {
+            name: "turbo-root",
+            filename: "turbo.json",
+            content
+        }
+    ];
+}
+function createTurboWorkspace(options) {
+    const opts = Schema.decodeUnknownSync(TurboWorkspaceOptions)(options);
+    const config = {
+        extends: [
+            "//"
+        ]
+    };
+    if (opts.tasks && Object.keys(opts.tasks).length > 0) config.tasks = opts.tasks;
+    const content = JSON.stringify(config, null, "\t");
+    return [
+        {
+            name: "turbo-workspace",
+            filename: "turbo.json",
+            content
+        }
+    ];
+}
+const Settings = Schema.Struct({
+    biome: Schema.optional(Schema.Boolean),
+    turbo: Schema.optional(Schema.Boolean),
+    vitest: Schema.optional(Schema.Boolean)
+});
+const VsCodeOptions = Schema.Struct({
+    settings: Schema.optional(Settings),
+    extensions: Schema.optional(Schema.Array(Schema.String))
+});
+function createVsCode(options) {
+    const opts = Schema.decodeUnknownSync(VsCodeOptions)(options);
+    const features = opts.settings ?? {};
+    const codeActions = {
+        "source.fixAll.ts": "explicit"
+    };
+    const searchExclude = {
+        "**/node_modules": true,
+        "**/dist": true,
+        "**/.rslib": true,
+        "**/*.tsbuildinfo": true
+    };
+    const filesExclude = {
+        "**/node_modules": true,
+        "**/dist": true,
+        "**/.rslib": true,
+        "**/*.tsbuildinfo": true
+    };
+    if (features.biome) {
+        codeActions["source.organizeImports.biome"] = "explicit";
+        codeActions["source.fixAll.biome"] = "explicit";
+    }
+    if (features.vitest) {
+        searchExclude["**/.vitest"] = true;
+        searchExclude["**/.coverage"] = true;
+        filesExclude["**/.vitest"] = true;
+        filesExclude["**/.coverage"] = true;
+    }
+    if (features.turbo) {
+        searchExclude["**/.turbo"] = true;
+        filesExclude["**/.turbo"] = true;
+    }
+    const settings = {
+        "editor.formatOnSave": true,
+        "eslint.enable": !features.biome,
+        "prettier.enable": !features.biome,
+        "biome.enabled": !!features.biome,
+        "biome.requireConfiguration": true,
+        "editor.codeActionsOnSave": codeActions,
+        "search.exclude": searchExclude,
+        "files.exclude": filesExclude
+    };
+    const recommendations = [
+        ...new Set(opts.extensions ?? [])
+    ].sort();
+    return [
+        {
+            name: "vscode-settings",
+            filename: ".vscode/settings.json",
+            content: JSON.stringify(settings, null, "\t")
+        },
+        {
+            name: "vscode-extensions",
+            filename: ".vscode/extensions.json",
+            content: JSON.stringify({
+                recommendations
+            }, null, "\t")
+        }
+    ];
+}
+const Features = Schema.Struct({
+    biome: Schema.optional(Schema.Boolean),
+    vitest: Schema.optional(Schema.Boolean),
+    turbo: Schema.optional(Schema.Boolean),
+    changesets: Schema.optional(Schema.Boolean),
+    vscode: Schema.optional(Schema.Boolean)
+});
+const WorkspaceOptions = Schema.Struct({
+    name: Schema.String,
+    packageManager: Schema.Literal("pnpm", "npm", "bun"),
+    packageManagerVersion: Schema.String,
+    nodeVersion: Schema.String,
+    biomeVersion: Schema.optionalWith(Schema.String, {
+        default: ()=>"2.3.3"
+    }),
+    features: Schema.optional(Features)
+});
+function createWorkspace(options) {
+    const opts = Schema.decodeUnknownSync(WorkspaceOptions)(options);
+    const features = opts.features ?? {};
+    const entries = [];
+    entries.push(...createPackageJson({
+        name: opts.name,
+        version: "0.0.0",
+        private: true,
+        type: "module",
+        packageManager: `${opts.packageManager}@${opts.packageManagerVersion}`,
+        engines: {
+            node: `>=${opts.nodeVersion}`
+        }
+    }));
+    entries.push(...createTsConfig({}));
+    entries.push(...createGitignore({
+        sections: {
+            os: true,
+            node: true,
+            build: true,
+            env: true,
+            silk: !!features.changesets
+        }
+    }));
+    entries.push(...createReadme({
+        name: opts.name
+    }));
+    if ("pnpm" === opts.packageManager) entries.push(...createPnpmWorkspace({
+        packages: [
+            "packages/*"
+        ],
+        autoInstallPeers: true
+    }));
+    if (features.biome) entries.push(...createBiome({
+        version: opts.biomeVersion,
+        root: true
+    }));
+    if (features.turbo) entries.push(...createTurboRoot({
+        tasks: {
+            build: {
+                dependsOn: [
+                    "^build"
+                ],
+                outputs: [
+                    "dist/**"
+                ]
+            },
+            test: {
+                dependsOn: [
+                    "build"
+                ]
+            },
+            "types:check": {
+                cache: true,
+                outputLogs: "errors-only"
+            }
+        },
+        globalPassThroughEnv: [
+            "CI",
+            "GITHUB_ACTIONS"
+        ]
+    }));
+    if (features.changesets) entries.push(...createChangeset({
+        access: "restricted"
+    }));
+    if (features.vscode) entries.push(...createVsCode({
+        settings: {
+            biome: !!features.biome,
+            turbo: !!features.turbo,
+            vitest: !!features.vitest
+        }
+    }));
+    return entries;
+}
+export { BiomeOptions, ChangesetOptions, GitignoreOptions, PackageJsonOptions, PnpmWorkspaceOptions, ReadmeOptions, TsConfigOptions, TurboRootOptions, TurboWorkspaceOptions, VsCodeOptions, WorkspaceOptions, createBiome, createChangeset, createGitignore, createPackageJson, createPnpmWorkspace, createReadme, createTsConfig, createTurboRoot, createTurboWorkspace, createVsCode, createWorkspace };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@savvy-web/templates",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Pure TypeScript templates for Silk Suite project scaffolding",
+  "homepage": "https://github.com/savvy-web/systems/tree/main/packages/templates",
+  "bugs": {
+    "url": "https://github.com/savvy-web/systems/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/savvy-web/systems.git",
+    "directory": "packages/templates"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "C. Spencer Beggs",
+    "email": "spencer@savvyweb.systems",
+    "url": "https://savvyweb.systems"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.1",
+    "sort-package-json": "^3.6.1"
+  },
+  "peerDependencies": {
+    "effect": ">=3.21.0"
+  },
+  "files": [
+    "!templates.api.json",
+    "!tsconfig.json",
+    "!tsdoc.json",
+    "LICENSE",
+    "README.md",
+    "index.d.ts",
+    "index.js",
+    "package.json",
+    "tsdoc-metadata.json"
+  ]
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.57.8"
+    }
+  ]
+}