@texuli/tools 0.0.0-stage → 0.1.0-next.0

package/dist/cli-add/provenance.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Provenance header stamped on every file `texuli add` writes.
+ * Later `texuli update` / `diff` tasks read this block.
+ */
+export type ProvenanceMeta = {
+    id: string;
+    package: string;
+    version: string;
+    /** Source path relative to the monorepo/package root. */
+    source: string;
+};
+/** Build the multi-line provenance comment body (no surrounding markers). */
+export declare function provenanceBody(meta: ProvenanceMeta): string;
+/** Block comment for TypeScript / CSS / JavaScript. */
+export declare function provenanceBlockComment(meta: ProvenanceMeta): string;
+/** HTML comment for Svelte markup files (safe above `<script>`). */
+export declare function provenanceHtmlComment(meta: ProvenanceMeta): string;
+/** Choose a header form from the destination file extension. */
+export declare function provenanceHeader(meta: ProvenanceMeta, fileName: string): string;
+/**
+ * The `source` a header records: the component directory relative to the
+ * source root (both real paths, computed by the caller) joined with the file's
+ * relative path, using `/`. Returns null when the result is not a plain
+ * relative path inside the root: empty, absolute, a `.` or `..` segment, a
+ * backslash, or a character that would break the header (`\0`, a line break,
+ * a comment end).
+ */
+export declare function provenanceSource(sourceDir: string, relativePath: string): string | null;
+/** Whether `source` is safe to stamp: relative, inside the root, header-safe. */
+export declare function isPlainSourcePath(source: string): boolean;
+/** True when file contents already carry a texuli add provenance block. */
+export declare function hasProvenance(content: string): boolean;

package/dist/cli-add/provenance.js

@@ -0,0 +1,78 @@
+/**
+ * Provenance header stamped on every file `texuli add` writes.
+ * Later `texuli update` / `diff` tasks read this block.
+ */
+const BEGIN = '@texuli/add — copied styled source. Do not remove this block.';
+/** Build the multi-line provenance comment body (no surrounding markers). */
+export function provenanceBody(meta) {
+    return [
+        BEGIN,
+        `id: ${meta.id}`,
+        `package: ${meta.package}`,
+        `version: ${meta.version}`,
+        `source: ${meta.source}`,
+    ].join('\n');
+}
+/** Block comment for TypeScript / CSS / JavaScript. */
+export function provenanceBlockComment(meta) {
+    const lines = provenanceBody(meta)
+        .split('\n')
+        .map((line) => ` * ${line}`)
+        .join('\n');
+    return `/**\n${lines}\n */\n`;
+}
+/** HTML comment for Svelte markup files (safe above `<script>`). */
+export function provenanceHtmlComment(meta) {
+    return `<!--\n${provenanceBody(meta)
+        .split('\n')
+        .map((line) => `  ${line}`)
+        .join('\n')}\n-->\n`;
+}
+/** Choose a header form from the destination file extension. */
+export function provenanceHeader(meta, fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith('.svelte'))
+        return provenanceHtmlComment(meta);
+    if (lower.endsWith('.ts') ||
+        lower.endsWith('.js') ||
+        lower.endsWith('.css') ||
+        lower.endsWith('.mjs') ||
+        lower.endsWith('.cjs')) {
+        return provenanceBlockComment(meta);
+    }
+    // Other text files get a # style header when they look like scripts; else HTML.
+    if (lower.endsWith('.md') || lower.endsWith('.txt')) {
+        return provenanceBody(meta)
+            .split('\n')
+            .map((line) => `# ${line}`)
+            .join('\n')
+            .concat('\n');
+    }
+    return provenanceHtmlComment(meta);
+}
+/**
+ * The `source` a header records: the component directory relative to the
+ * source root (both real paths, computed by the caller) joined with the file's
+ * relative path, using `/`. Returns null when the result is not a plain
+ * relative path inside the root: empty, absolute, a `.` or `..` segment, a
+ * backslash, or a character that would break the header (`\0`, a line break,
+ * a comment end).
+ */
+export function provenanceSource(sourceDir, relativePath) {
+    const source = [sourceDir, relativePath].filter((part) => part.length > 0).join('/');
+    return isPlainSourcePath(source) ? source : null;
+}
+/** Whether `source` is safe to stamp: relative, inside the root, header-safe. */
+export function isPlainSourcePath(source) {
+    if (source.length === 0 || source.startsWith('/') || /^[A-Za-z]:/.test(source))
+        return false;
+    if (/[\\\0\r\n]/.test(source) || source.includes('*/') || source.includes('-->'))
+        return false;
+    return source
+        .split('/')
+        .every((segment) => segment !== '' && segment !== '.' && segment !== '..');
+}
+/** True when file contents already carry a texuli add provenance block. */
+export function hasProvenance(content) {
+    return content.includes('@texuli/add');
+}

package/dist/cli-add/registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Styled components `texuli add` may copy. Paths are under the owning package
+ * root and never under `packages/primitives`.
+ */
+import type { AddableComponent } from './types.js';
+/**
+ * Built-in addable set: styled `texuli` components only.
+ * Primitives, tokens and engines are intentionally absent.
+ */
+export declare const DEFAULT_ADD_REGISTRY: readonly AddableComponent[];
+/** Look up a styled component by id, or `undefined` when unknown / not addable. */
+export declare function getAddable(id: string, registry?: readonly AddableComponent[]): AddableComponent | undefined;
+/** Every addable id (sorted). */
+export declare function listAddableIds(registry?: readonly AddableComponent[]): string[];
+/**
+ * True when a path segment would pull primitives (forbidden for add).
+ * Used as a belt-and-braces check on resolved source paths.
+ */
+export declare function isPrimitivesPath(absolutePath: string): boolean;

package/dist/cli-add/registry.js

@@ -0,0 +1,50 @@
+const TEXULI = 'texuli';
+function texuliComponent(id, folder = id, peers) {
+    return {
+        id,
+        package: TEXULI,
+        directory: `src/components/${folder}`,
+        ...(peers ? { peers } : {}),
+    };
+}
+/**
+ * Built-in addable set: styled `texuli` components only.
+ * Primitives, tokens and engines are intentionally absent.
+ */
+export const DEFAULT_ADD_REGISTRY = Object.freeze([
+    texuliComponent('alert'),
+    texuliComponent('badge'),
+    texuliComponent('button', 'button', ['texuli/cx']),
+    texuliComponent('card', 'card', ['texuli/cx']),
+    texuliComponent('empty'),
+    texuliComponent('field'),
+    texuliComponent('input'),
+    texuliComponent('kbd-code', 'kbd-code'),
+    texuliComponent('stat'),
+    texuliComponent('stepper', 'stepper', ['texuli/cx', 'texuli/button']),
+    texuliComponent('table', 'table', ['texuli/cx']),
+    texuliComponent('tabs-accordion', 'tabs-accordion', ['texuli/cx']),
+    texuliComponent('toast', 'toast', ['texuli/cx']),
+    texuliComponent('dialog', 'dialog', ['texuli/cx', 'texuli/button', 'texuli/icons']),
+]);
+const BY_ID = new Map(DEFAULT_ADD_REGISTRY.map((entry) => [entry.id, entry]));
+/** Look up a styled component by id, or `undefined` when unknown / not addable. */
+export function getAddable(id, registry = DEFAULT_ADD_REGISTRY) {
+    if (registry === DEFAULT_ADD_REGISTRY)
+        return BY_ID.get(id);
+    return registry.find((entry) => entry.id === id);
+}
+/** Every addable id (sorted). */
+export function listAddableIds(registry = DEFAULT_ADD_REGISTRY) {
+    return registry.map((entry) => entry.id).sort();
+}
+/**
+ * True when a path segment would pull primitives (forbidden for add).
+ * Used as a belt-and-braces check on resolved source paths.
+ */
+export function isPrimitivesPath(absolutePath) {
+    const normalized = absolutePath.replace(/\\/g, '/');
+    return (/\/packages\/primitives(\/|$)/.test(normalized) ||
+        /\/@texuli\/primitives(\/|$)/.test(normalized) ||
+        /\/primitives\/src\//.test(normalized));
+}

package/dist/cli-add/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Types for `texuli add` — copy styled component source into a consumer app.
+ */
+/** One file the add command will write. */
+export type AddFilePlan = {
+    /** Path relative to the component source directory. */
+    relativePath: string;
+    /** Absolute path of the source file. */
+    from: string;
+    /** Absolute path of the destination file. */
+    to: string;
+    /** Bytes of the source before the provenance header. */
+    sourceBytes: number;
+};
+/** Result of one `add` run (human or `--json`). */
+export type AddResult = {
+    ok: boolean;
+    /** Component id requested. */
+    id: string;
+    /** Package that owns the styled source. */
+    package: string;
+    /** Directory written under the consumer project. */
+    outDir: string;
+    /** Files written or that would be written (`dryRun`). */
+    files: Array<{
+        path: string;
+        action: 'write' | 'skip' | 'would-write';
+        bytes: number;
+    }>;
+    errors: string[];
+    /** True when nothing was written because of `--dry-run`. */
+    dryRun: boolean;
+};
+/** A styled component the add command may copy. Never primitives. */
+export type AddableComponent = {
+    /** Closed kebab-case id (matches catalog when present). */
+    id: string;
+    /** Workspace package name, e.g. `texuli`. */
+    package: string;
+    /**
+     * Directory under the package root that holds the styled source
+     * (for example `src/components/button`). Copied recursively.
+     */
+    directory: string;
+    /** Optional peer import hints for the consumer. */
+    peers?: readonly string[];
+};
+export type AddOptions = {
+    /** Component id to copy. */
+    id: string;
+    /** Consumer project root (files land under `outDir`). */
+    cwd: string;
+    /**
+     * Absolute path to the monorepo (or fixture) root that holds
+     * `packages/<pkg>/…` source. No network — local paths only.
+     */
+    sourceRoot: string;
+    /**
+     * Destination directory relative to `cwd`
+     * (default `src/components/texuli/<id>`).
+     */
+    outDir?: string;
+    /** Package version stamped into the provenance header. */
+    version?: string;
+    /** When true, refuse to overwrite existing files. Default true. */
+    force?: boolean;
+    /** Plan only; write nothing. */
+    dryRun?: boolean;
+    /** Override the built-in registry (tests). */
+    registry?: readonly AddableComponent[];
+};

package/dist/cli-add/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for `texuli add` — copy styled component source into a consumer app.
+ */
+export {};

package/dist/cli-init/cli.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import type { Framework } from './types.js';
+export declare const USAGE = "Usage:\n  texuli init [options]              Wire Texuli tokens and CSS into a Vite, Astro or SvelteKit project\n  texuli theme list [--search <q>]   List the theme library\n  texuli theme preview <id>          Show a theme's key tokens and its WCAG AA report\n  texuli theme apply <id>            Switch an initialized project to another theme\n\nOptions:\n  --cwd <dir>          Project root (default: current directory)\n  --framework <name>   vite | astro | sveltekit (default: detected from package.json)\n  --theme <id>         Theme for init (default: enterprise-neutral)\n  --css <path>         Stylesheet path, relative to the project (default per framework)\n  --namespace <id>     No-flash appearance namespace (default: app)\n  --mode <light|dark>  Preview mode (default: light)\n  --search <words>     Filter theme list\n  --force              Replace a stylesheet or config texuli did not generate (never follows symlinks)\n  --dry-run            Plan only; write nothing\n  --json               Machine-readable output\n  --help               Show this help\n";
+export interface InitCliArgs {
+    command: 'init' | 'theme-list' | 'theme-preview' | 'theme-apply' | 'help';
+    id: string | null;
+    cwd: string;
+    framework: Framework | null;
+    theme: string | null;
+    css: string | null;
+    namespace: string | null;
+    mode: 'light' | 'dark';
+    search: string | null;
+    force: boolean;
+    dryRun: boolean;
+    json: boolean;
+}
+/** Parses `init …` or `theme <list|preview|apply> …`. Throws on bad input. */
+export declare function parseInitArgs(argv: readonly string[], cwd?: string): InitCliArgs;
+/** Runs the CLI; returns the exit code. `io` defaults to the console. */
+export declare function runInitCli(argv: readonly string[], io?: {
+    cwd?: string;
+    out?: (line: string) => void;
+    err?: (line: string) => void;
+}): Promise<number>;

package/dist/cli-init/cli.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+/**
+ * `texuli init` and `texuli theme`. No network.
+ *
+ *   pnpm exec tsx packages/tools/src/cli-init/cli.ts init [--cwd <app>] [--framework vite|astro|sveltekit]
+ *     [--theme <id>] [--css <path>] [--namespace <id>] [--force] [--dry-run] [--json]
+ *   pnpm exec tsx packages/tools/src/cli-init/cli.ts theme list [--search <words>] [--json]
+ *   pnpm exec tsx packages/tools/src/cli-init/cli.ts theme preview <id> [--mode light|dark] [--json]
+ *   pnpm exec tsx packages/tools/src/cli-init/cli.ts theme apply <id> [--cwd <app>] [--force] [--dry-run] [--json]
+ */
+import { fileURLToPath } from 'node:url';
+import { FRAMEWORKS } from "./detect.js";
+import { initProject } from "./init.js";
+import { applyProjectTheme } from "./theme-apply.js";
+import { listThemes, previewTheme } from "./themes.js";
+export const USAGE = `Usage:
+  texuli init [options]              Wire Texuli tokens and CSS into a Vite, Astro or SvelteKit project
+  texuli theme list [--search <q>]   List the theme library
+  texuli theme preview <id>          Show a theme's key tokens and its WCAG AA report
+  texuli theme apply <id>            Switch an initialized project to another theme
+
+Options:
+  --cwd <dir>          Project root (default: current directory)
+  --framework <name>   vite | astro | sveltekit (default: detected from package.json)
+  --theme <id>         Theme for init (default: enterprise-neutral)
+  --css <path>         Stylesheet path, relative to the project (default per framework)
+  --namespace <id>     No-flash appearance namespace (default: app)
+  --mode <light|dark>  Preview mode (default: light)
+  --search <words>     Filter theme list
+  --force              Replace a stylesheet or config texuli did not generate (never follows symlinks)
+  --dry-run            Plan only; write nothing
+  --json               Machine-readable output
+  --help               Show this help
+`;
+/** Parses `init …` or `theme <list|preview|apply> …`. Throws on bad input. */
+export function parseInitArgs(argv, cwd = process.cwd()) {
+    const rest = [...argv];
+    const args = {
+        command: 'help',
+        id: null,
+        cwd,
+        framework: null,
+        theme: null,
+        css: null,
+        namespace: null,
+        mode: 'light',
+        search: null,
+        force: false,
+        dryRun: false,
+        json: false,
+    };
+    const verb = rest.shift();
+    if (verb === 'init')
+        args.command = 'init';
+    else if (verb === 'theme') {
+        const sub = rest.shift();
+        if (sub === 'list')
+            args.command = 'theme-list';
+        else if (sub === 'preview')
+            args.command = 'theme-preview';
+        else if (sub === 'apply')
+            args.command = 'theme-apply';
+        else
+            throw new Error(`Unknown theme command: ${sub ?? '(none)'}`);
+    }
+    else if (verb !== undefined && verb !== '--help' && verb !== '-h') {
+        throw new Error(`Unknown command: ${verb}`);
+    }
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        const value = () => {
+            const next = rest[index + 1];
+            if (next === undefined || next.startsWith('--'))
+                throw new Error(`${arg} needs a value`);
+            index += 1;
+            return next;
+        };
+        if (arg === '--help' || arg === '-h')
+            args.command = 'help';
+        else if (arg === '--json')
+            args.json = true;
+        else if (arg === '--force')
+            args.force = true;
+        else if (arg === '--dry-run')
+            args.dryRun = true;
+        else if (arg === '--cwd')
+            args.cwd = value();
+        else if (arg === '--theme')
+            args.theme = value();
+        else if (arg === '--css')
+            args.css = value();
+        else if (arg === '--namespace')
+            args.namespace = value();
+        else if (arg === '--search')
+            args.search = value();
+        else if (arg === '--framework') {
+            const name = value();
+            if (!FRAMEWORKS.includes(name))
+                throw new Error(`--framework must be one of ${FRAMEWORKS.join(', ')}`);
+            args.framework = name;
+        }
+        else if (arg === '--mode') {
+            const mode = value();
+            if (mode !== 'light' && mode !== 'dark')
+                throw new Error('--mode must be light or dark');
+            args.mode = mode;
+        }
+        else if (arg.startsWith('-'))
+            throw new Error(`Unknown option: ${arg}`);
+        else if (args.id === null &&
+            (args.command === 'theme-preview' || args.command === 'theme-apply'))
+            args.id = arg;
+        else
+            throw new Error(`Unexpected argument: ${arg}`);
+    }
+    if ((args.command === 'theme-preview' || args.command === 'theme-apply') && !args.id) {
+        throw new Error('A theme id is required.');
+    }
+    return args;
+}
+function printResult(result, out, err) {
+    for (const error of result.errors)
+        err(error);
+    for (const file of result.files) {
+        out(`  ${(result.dryRun && file.action !== 'unchanged' ? `would ${file.action}` : file.action).padEnd(14)} ${file.path}`);
+    }
+    for (const note of result.notes)
+        out(`note: ${note}`);
+}
+/** Runs the CLI; returns the exit code. `io` defaults to the console. */
+export async function runInitCli(argv, io = {}) {
+    const out = io.out ?? ((line) => console.log(line));
+    const err = io.err ?? ((line) => console.error(line));
+    let args;
+    try {
+        args = parseInitArgs(argv, io.cwd);
+    }
+    catch (error) {
+        err(error instanceof Error ? error.message : String(error));
+        err(USAGE);
+        return 1;
+    }
+    switch (args.command) {
+        case 'help':
+            out(USAGE);
+            return 0;
+        case 'theme-list': {
+            const themes = await listThemes(args.search ?? undefined);
+            if (args.json)
+                out(JSON.stringify({ themes }));
+            else
+                for (const theme of themes)
+                    out(`${theme.id.padEnd(28)} ${theme.name} (${theme.collection}, ${theme.contrastLevel}${theme.darkFirst ? ', dark-first' : ''})`);
+            return 0;
+        }
+        case 'theme-preview': {
+            const preview = await previewTheme(args.id, args.mode);
+            if (!preview) {
+                err(`Unknown theme: ${args.id}. Run \`texuli theme list\`.`);
+                return 1;
+            }
+            if (args.json)
+                out(JSON.stringify(preview));
+            else {
+                out(`${preview.name} (${preview.id}), ${preview.mode}: ${preview.description}`);
+                for (const [name, value] of Object.entries(preview.tokens))
+                    out(`  ${name.padEnd(26)} ${value}`);
+                out(`WCAG AA: ${preview.aa.pass ? 'pass' : `${preview.aa.issues} issue(s)`} (${preview.aa.modes.map((mode) => `${mode.mode} ${mode.pass ? 'pass' : `${mode.issues} issue(s)`}`).join(', ')})`);
+            }
+            return 0;
+        }
+        case 'theme-apply':
+        case 'init': {
+            const result = args.command === 'init'
+                ? await initProject({
+                    cwd: args.cwd,
+                    ...(args.framework ? { framework: args.framework } : {}),
+                    ...(args.theme ? { theme: args.theme } : {}),
+                    ...(args.css ? { css: args.css } : {}),
+                    ...(args.namespace ? { namespace: args.namespace } : {}),
+                    force: args.force,
+                    dryRun: args.dryRun,
+                })
+                : await applyProjectTheme({
+                    cwd: args.cwd,
+                    theme: args.id,
+                    force: args.force,
+                    dryRun: args.dryRun,
+                });
+            if (args.json)
+                out(JSON.stringify(result));
+            else
+                printResult(result, out, err);
+            return result.ok ? 0 : 1;
+        }
+    }
+}
+function isMain(metaUrl) {
+    const entry = process.argv[1];
+    try {
+        return entry !== undefined && fileURLToPath(metaUrl) === entry;
+    }
+    catch {
+        return false;
+    }
+}
+if (isMain(import.meta.url)) {
+    runInitCli(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });
+}

package/dist/cli-init/config.d.ts

@@ -0,0 +1,10 @@
+import type { TexuliConfig } from './types.js';
+export declare const CONFIG_FILE = "texuli.config.json";
+/** Parses and validates `texuli.config.json`; returns errors for anything unsafe or unknown. */
+export declare function parseConfig(text: string): {
+    config: TexuliConfig;
+} | {
+    errors: string[];
+};
+export declare function formatConfig(config: TexuliConfig): string;
+export declare function isId(value: string): boolean;

package/dist/cli-init/config.js

@@ -0,0 +1,62 @@
+import { FRAMEWORKS } from "./detect.js";
+import { projectPathError } from "./safe-path.js";
+export const CONFIG_FILE = 'texuli.config.json';
+const ID = /^[a-z][a-z0-9-]{0,79}$/;
+/** Parses and validates `texuli.config.json`; returns errors for anything unsafe or unknown. */
+export function parseConfig(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch (error) {
+        return {
+            errors: [
+                `${CONFIG_FILE} is not JSON: ${error instanceof Error ? error.message : String(error)}`,
+            ],
+        };
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return { errors: [`${CONFIG_FILE} must be a JSON object.`] };
+    }
+    const record = raw;
+    const errors = [];
+    if (!FRAMEWORKS.includes(record.framework)) {
+        errors.push(`${CONFIG_FILE} framework must be one of ${FRAMEWORKS.join(', ')}.`);
+    }
+    for (const field of ['css', 'entry', 'document']) {
+        const error = projectPathError(`${CONFIG_FILE} ${field}`, record[field]);
+        if (error)
+            errors.push(error);
+    }
+    for (const field of ['theme', 'namespace']) {
+        if (typeof record[field] !== 'string' || !ID.test(record[field])) {
+            errors.push(`${CONFIG_FILE} ${field} must be a kebab-case id.`);
+        }
+    }
+    if (errors.length > 0)
+        return { errors };
+    return {
+        config: {
+            framework: record.framework,
+            css: record.css,
+            entry: record.entry,
+            document: record.document,
+            theme: record.theme,
+            namespace: record.namespace,
+        },
+    };
+}
+export function formatConfig(config) {
+    const ordered = {
+        framework: config.framework,
+        css: config.css,
+        entry: config.entry,
+        document: config.document,
+        theme: config.theme,
+        namespace: config.namespace,
+    };
+    return `${JSON.stringify(ordered, null, 2)}\n`;
+}
+export function isId(value) {
+    return ID.test(value);
+}

package/dist/cli-init/detect.d.ts

@@ -0,0 +1,13 @@
+import type { Framework } from './types.js';
+export declare const FRAMEWORKS: readonly Framework[];
+/**
+ * The framework a `package.json` declares, most specific first: SvelteKit
+ * (it also uses Vite), then Astro, then Vite. `null` when none is declared.
+ */
+export declare function detectFramework(packageJson: unknown): Framework | null;
+/** Default file locations per framework (relative, forward slashes). */
+export declare const DEFAULTS: Record<Framework, {
+    css: string;
+    entries: readonly string[];
+    document: readonly string[];
+}>;

package/dist/cli-init/detect.js

@@ -0,0 +1,42 @@
+export const FRAMEWORKS = ['sveltekit', 'astro', 'vite'];
+/**
+ * The framework a `package.json` declares, most specific first: SvelteKit
+ * (it also uses Vite), then Astro, then Vite. `null` when none is declared.
+ */
+export function detectFramework(packageJson) {
+    if (typeof packageJson !== 'object' || packageJson === null)
+        return null;
+    const record = packageJson;
+    const names = new Set();
+    for (const field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+        const deps = record[field];
+        if (typeof deps === 'object' && deps !== null)
+            for (const name of Object.keys(deps))
+                names.add(name);
+    }
+    if (names.has('@sveltejs/kit'))
+        return 'sveltekit';
+    if (names.has('astro'))
+        return 'astro';
+    if (names.has('vite'))
+        return 'vite';
+    return null;
+}
+/** Default file locations per framework (relative, forward slashes). */
+export const DEFAULTS = {
+    vite: {
+        css: 'src/texuli.css',
+        entries: ['src/main.ts', 'src/main.js'],
+        document: ['index.html'],
+    },
+    sveltekit: {
+        css: 'src/texuli.css',
+        entries: ['src/routes/+layout.svelte'],
+        document: ['src/app.html'],
+    },
+    astro: {
+        css: 'src/styles/texuli.css',
+        entries: ['src/layouts/Layout.astro', 'src/layouts/BaseLayout.astro'],
+        document: ['src/layouts/Layout.astro', 'src/layouts/BaseLayout.astro'],
+    },
+};

package/dist/cli-init/files.d.ts

@@ -0,0 +1,18 @@
+import type { FileChange } from './types.js';
+export interface Project {
+    /** Real path of the project root. */
+    root: string;
+}
+export declare function openProject(cwd: string): Project | string;
+/** Resolves a project-relative path, or explains why it is refused. */
+export declare function resolveInProject(project: Project, rel: string, name?: string): string | {
+    error: string;
+};
+/** Reads a project file (null when missing), refusing paths outside the project or through symlinks. */
+export declare function readProjectFile(project: Project, rel: string, name?: string): Promise<string | null | {
+    error: string;
+}>;
+/** A planned write: compare, then (unless dry run) write through the containment checks again. */
+export declare function writeProjectFile(project: Project, rel: string, before: string | null, after: string, dryRun: boolean): Promise<FileChange | {
+    error: string;
+}>;