@tanstack/cta-engine 0.48.0 → 0.49.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @tanstack/cta-engine
 
+## 0.49.1
+
+### Patch Changes
+
+- fix: remove relative file prefixes ([`78af490`](https://github.com/TanStack/create-tsrouter-app/commit/78af49072b54a08ebfdafe72be146efecf4ce77c))
+
+## 0.49.0
+
+### Minor Changes
+
+- Added categories, colors, exclusive tagging, addon file attribution utils, and railway addon ([#303](https://github.com/TanStack/create-tsrouter-app/pull/303))
+
 ## 0.48.0
 
 ### Minor Changes

package/dist/attribution.js

@@ -0,0 +1,162 @@
+function normalizePath(path) {
+    let p = path.startsWith('./') ? path.slice(2) : path;
+    p = p.replace(/\.ejs$/, '').replace(/_dot_/g, '.');
+    const match = p.match(/^(.+\/)?__([^_]+)__(.+)$/);
+    return match ? (match[1] || '') + match[3] : p;
+}
+async function getFileProvenance(filePath, framework, addOns, starter) {
+    const target = filePath.startsWith('./') ? filePath.slice(2) : filePath;
+    if (starter) {
+        const files = await starter.getFiles();
+        if (files.some((f) => normalizePath(f) === target)) {
+            return {
+                source: 'starter',
+                sourceId: starter.id,
+                sourceName: starter.name,
+            };
+        }
+    }
+    // Order add-ons by type then phase (matches writeFiles order), check in reverse
+    const typeOrder = ['add-on', 'example', 'toolchain', 'deployment'];
+    const phaseOrder = ['setup', 'add-on', 'example'];
+    const ordered = typeOrder.flatMap((type) => phaseOrder.flatMap((phase) => addOns.filter((a) => a.phase === phase && a.type === type)));
+    for (let i = ordered.length - 1; i >= 0; i--) {
+        const files = await ordered[i].getFiles();
+        if (files.some((f) => normalizePath(f) === target)) {
+            return {
+                source: 'add-on',
+                sourceId: ordered[i].id,
+                sourceName: ordered[i].name,
+            };
+        }
+    }
+    const frameworkFiles = await framework.getFiles();
+    if (frameworkFiles.some((f) => normalizePath(f) === target)) {
+        return {
+            source: 'framework',
+            sourceId: framework.id,
+            sourceName: framework.name,
+        };
+    }
+    return null;
+}
+// Build injection patterns from integrations (for source files)
+function integrationInjections(int) {
+    const source = { sourceId: int._sourceId, sourceName: int._sourceName };
+    const injections = [];
+    const appliesTo = (path) => {
+        if (int.type === 'vite-plugin')
+            return path.includes('vite.config');
+        if (int.type === 'provider' ||
+            int.type === 'root-provider' ||
+            int.type === 'devtools') {
+            return path.includes('__root') || path.includes('root.tsx');
+        }
+        return false;
+    };
+    if (int.import) {
+        const prefix = int.import.split(' from ')[0];
+        injections.push({
+            matches: (line) => line.includes(prefix),
+            appliesTo,
+            source,
+        });
+    }
+    const code = int.code || int.jsName;
+    if (code) {
+        injections.push({
+            matches: (line) => line.includes(code),
+            appliesTo,
+            source,
+        });
+    }
+    return injections;
+}
+// Build injection pattern from a dependency (for package.json)
+function dependencyInjection(dep) {
+    return {
+        matches: (line) => line.includes(`"${dep.name}"`),
+        appliesTo: (path) => path.endsWith('package.json'),
+        source: { sourceId: dep.sourceId, sourceName: dep.sourceName },
+    };
+}
+export async function computeAttribution(input) {
+    const { framework, chosenAddOns, starter, files } = input;
+    // Collect integrations tagged with source
+    const integrations = chosenAddOns.flatMap((addOn) => (addOn.integrations || []).map((int) => ({
+        ...int,
+        _sourceId: addOn.id,
+        _sourceName: addOn.name,
+    })));
+    // Collect dependencies from add-ons (from packageAdditions or packageTemplate)
+    const dependencies = chosenAddOns.flatMap((addOn) => {
+        const result = [];
+        const source = { sourceId: addOn.id, sourceName: addOn.name };
+        const addDeps = (deps, type) => {
+            if (!deps)
+                return;
+            for (const [name, version] of Object.entries(deps)) {
+                if (typeof version === 'string') {
+                    result.push({ name, version, type, ...source });
+                }
+            }
+        };
+        // From static package.json
+        addDeps(addOn.packageAdditions?.dependencies, 'dependency');
+        addDeps(addOn.packageAdditions?.devDependencies, 'devDependency');
+        // From package.json.ejs template (strip EJS tags and parse)
+        if (addOn.packageTemplate) {
+            try {
+                const tmpl = JSON.parse(addOn.packageTemplate.replace(/"[^"]*<%[^%]*%>[^"]*"/g, '""'));
+                addDeps(tmpl.dependencies, 'dependency');
+                addDeps(tmpl.devDependencies, 'devDependency');
+            }
+            catch { }
+        }
+        return result;
+    });
+    // Build unified injection patterns from both integrations and dependencies
+    const injections = [
+        ...integrations.flatMap(integrationInjections),
+        ...dependencies.map(dependencyInjection),
+    ];
+    const attributedFiles = {};
+    for (const [filePath, content] of Object.entries(files)) {
+        const provenance = await getFileProvenance(filePath, framework, chosenAddOns, starter);
+        if (!provenance)
+            continue;
+        const lines = content.split('\n');
+        const relevant = injections.filter((inj) => inj.appliesTo(filePath));
+        // Find injected lines
+        const injectedLines = new Map();
+        for (const inj of relevant) {
+            lines.forEach((line, i) => {
+                if (inj.matches(line) && !injectedLines.has(i + 1)) {
+                    injectedLines.set(i + 1, inj.source);
+                }
+            });
+        }
+        attributedFiles[filePath] = {
+            content,
+            provenance,
+            lineAttributions: lines.map((_, i) => {
+                const lineNum = i + 1;
+                const inj = injectedLines.get(lineNum);
+                return inj
+                    ? {
+                        line: lineNum,
+                        sourceId: inj.sourceId,
+                        sourceName: inj.sourceName,
+                        type: 'injected',
+                    }
+                    : {
+                        line: lineNum,
+                        sourceId: provenance.sourceId,
+                        sourceName: provenance.sourceName,
+                        type: 'original',
+                    };
+            }),
+        };
+    }
+    return { attributedFiles, dependencies };
+}

package/dist/custom-add-ons/shared.js

@@ -5,7 +5,7 @@ import { createMemoryEnvironment } from '../environment.js';
 import { finalizeAddOns, populateAddOnOptionsDefaults } from '../add-ons.js';
 import { getFrameworkById } from '../frameworks.js';
 import { readConfigFileFromEnvironment } from '../config-file.js';
-import { readFileHelper } from '../file-helpers.js';
+import { readFileHelper, toCleanPath } from '../file-helpers.js';
 import { loadStarter } from '../custom-add-ons/starter.js';
 export function createPackageAdditions(originalPackageJson, currentPackageJson) {
     const packageAdditions = {};
@@ -87,9 +87,10 @@ export async function runCreateApp(options) {
         ...options,
         targetDir,
     });
-    output.files = Object.fromEntries(Object.entries(output.files).map(([key, value]) => {
-        return [key.replace(targetDir, '.'), value];
-    }));
+    output.files = Object.fromEntries(Object.entries(output.files).map(([key, value]) => [
+        toCleanPath(key, targetDir),
+        value,
+    ]));
     return output;
 }
 export async function compareFilesRecursively(path, ignore, original, changedFiles) {

package/dist/file-helpers.js

@@ -28,6 +28,16 @@ export function getBinaryFile(content) {
     }
     return null;
 }
+/**
+ * Convert an absolute path to a clean relative path by removing a base directory.
+ * Returns a path without leading ./ or / prefix.
+ */
+export function toCleanPath(absolutePath, baseDir) {
+    let cleanPath = absolutePath.replace(baseDir, '');
+    if (cleanPath.startsWith('/'))
+        cleanPath = cleanPath.slice(1);
+    return cleanPath;
+}
 export function relativePath(from, to, stripExtension = false) {
     const fixedOnWindows = from.startsWith('.\\')
         ? from.replace(/\\/g, '/')
@@ -88,7 +98,7 @@ async function recursivelyGatherFilesHelper(basePath, path, files, ignore) {
         }
         else {
             const filePath = resolve(path, file.name);
-            files[filePath.replace(basePath, '.')] = await readFileHelper(filePath);
+            files[toCleanPath(filePath, basePath)] = await readFileHelper(filePath);
         }
     }
 }
@@ -109,7 +119,7 @@ async function recursivelyGatherFilesFromEnvironmentHelper(environment, basePath
         }
         else {
             const filePath = resolve(path, file);
-            files[filePath.replace(basePath, '.')] =
+            files[toCleanPath(filePath, basePath)] =
                 await environment.readFile(filePath);
         }
     }
@@ -158,7 +168,7 @@ export function createIgnore(path, includeProjectFiles = true) {
 export function cleanUpFiles(files, targetDir) {
     return Object.keys(files).reduce((acc, file) => {
         if (basename(file) !== '.cta.json') {
-            acc[targetDir ? file.replace(targetDir, '.') : file] = files[file];
+            acc[targetDir ? toCleanPath(file, targetDir) : file] = files[file];
         }
         return acc;
     }, {});
@@ -166,7 +176,7 @@ export function cleanUpFiles(files, targetDir) {
 export function cleanUpFileArray(files, targetDir) {
     return files.reduce((acc, file) => {
         if (basename(file) !== '.cta.json') {
-            acc.push(targetDir ? file.replace(targetDir, '.') : file);
+            acc.push(targetDir ? toCleanPath(file, targetDir) : file);
         }
         return acc;
     }, []);

package/dist/frameworks.js

@@ -1,12 +1,12 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { findFilesRecursively, isDirectory, readFileHelper, } from './file-helpers.js';
+import { findFilesRecursively, isDirectory, readFileHelper, toCleanPath, } from './file-helpers.js';
 const frameworks = [];
 export function scanProjectDirectory(projectDirectory, baseDirectory) {
     const absolutePaths = {};
     findFilesRecursively(baseDirectory, absolutePaths);
     const files = Object.keys(absolutePaths).reduce((acc, path) => {
-        acc[path.replace(baseDirectory, '.')] = absolutePaths[path];
+        acc[toCleanPath(path, baseDirectory)] = absolutePaths[path];
         return acc;
     }, {});
     const basePackageJSON = existsSync(resolve(baseDirectory, 'package.json'))
@@ -52,7 +52,7 @@ export function scanAddOnDirectories(addOnsDirectories) {
             }
             const files = {};
             for (const file of Object.keys(absoluteFiles)) {
-                files[file.replace(assetsDir, '.')] = readFileHelper(file);
+                files[toCleanPath(file, assetsDir)] = readFileHelper(file);
             }
             const getFiles = () => {
                 return Promise.resolve(Object.keys(files));

package/dist/index.js

@@ -1,6 +1,7 @@
 export { createApp } from './create-app.js';
+export { computeAttribution } from './attribution.js';
 export { addToApp } from './add-to-app.js';
-export { finalizeAddOns, getAllAddOns, populateAddOnOptionsDefaults } from './add-ons.js';
+export { finalizeAddOns, getAllAddOns, populateAddOnOptionsDefaults, } from './add-ons.js';
 export { loadRemoteAddOn } from './custom-add-ons/add-on.js';
 export { loadStarter } from './custom-add-ons/starter.js';
 export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
@@ -8,7 +9,7 @@ export { CONFIG_FILE } from './constants.js';
 export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
 export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, scanProjectDirectory, scanAddOnDirectories, } from './frameworks.js';
 export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, readConfigFile, } from './config-file.js';
-export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, } from './file-helpers.js';
+export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, toCleanPath, } from './file-helpers.js';
 export { formatCommand, handleSpecialURL } from './utils.js';
 export { initStarter, compileStarter } from './custom-add-ons/starter.js';
 export { initAddOn, compileAddOn } from './custom-add-ons/add-on.js';

package/dist/template-file.js

@@ -26,11 +26,16 @@ export function createTemplateFile(environment, options) {
             this.name = 'IgnoreFileError';
         }
     }
+    // Collect integrations and tag them with source add-on for attribution
     const integrations = [];
     for (const addOn of options.chosenAddOns) {
         if (addOn.integrations) {
             for (const integration of addOn.integrations) {
-                integrations.push(integration);
+                integrations.push({
+                    ...integration,
+                    _sourceId: addOn.id,
+                    _sourceName: addOn.name,
+                });
             }
         }
     }

package/dist/types/attribution.d.ts

@@ -0,0 +1,12 @@
+import type { AddOn, AttributedFile, DependencyAttribution, Framework, Starter } from './types.js';
+export interface AttributionInput {
+    framework: Framework;
+    chosenAddOns: Array<AddOn>;
+    starter?: Starter;
+    files: Record<string, string>;
+}
+export interface AttributionOutput {
+    attributedFiles: Record<string, AttributedFile>;
+    dependencies: Array<DependencyAttribution>;
+}
+export declare function computeAttribution(input: AttributionInput): Promise<AttributionOutput>;

package/dist/types/custom-add-ons/add-on.d.ts

@@ -39,6 +39,9 @@ export declare function generateProject(persistedOptions: PersistedOptions): Pro
         link?: string | undefined;
         license?: string | undefined;
         warning?: string | undefined;
+        category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+        exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+        color?: string | undefined;
         priority?: number | undefined;
         routes?: {
             path: string;
@@ -67,14 +70,7 @@ export declare function generateProject(persistedOptions: PersistedOptions): Pro
         }[] | undefined;
         readme?: string | undefined;
     };
-    output: {
-        files: Record<string, string>;
-        deletedFiles: Array<string>;
-        commands: Array<{
-            command: string;
-            args: Array<string>;
-        }>;
-    };
+    output: import("../environment.js").MemoryEnvironmentOutput;
 }>;
 export declare function buildAssetsDirectory(output: {
     files: Record<string, string>;

package/dist/types/custom-add-ons/shared.d.ts

@@ -3,13 +3,6 @@ import type { PersistedOptions } from '../config-file.js';
 export declare function createPackageAdditions(originalPackageJson: Record<string, any>, currentPackageJson: Record<string, any>): Record<string, any>;
 export declare function createAppOptionsFromPersisted(json: PersistedOptions): Promise<Options>;
 export declare function createSerializedOptionsFromPersisted(json: PersistedOptions): SerializedOptions;
-export declare function runCreateApp(options: Required<Options>): Promise<{
-    files: Record<string, string>;
-    deletedFiles: Array<string>;
-    commands: Array<{
-        command: string;
-        args: Array<string>;
-    }>;
-}>;
+export declare function runCreateApp(options: Required<Options>): Promise<import("../environment.js").MemoryEnvironmentOutput>;
 export declare function compareFilesRecursively(path: string, ignore: (filePath: string) => boolean, original: Record<string, string>, changedFiles: Record<string, string>): Promise<void>;
 export declare function readCurrentProjectOptions(environment: Environment): Promise<PersistedOptions>;

package/dist/types/environment.d.ts

@@ -1,13 +1,14 @@
 import type { Environment } from './types.js';
+export interface MemoryEnvironmentOutput {
+    files: Record<string, string>;
+    deletedFiles: Array<string>;
+    commands: Array<{
+        command: string;
+        args: Array<string>;
+    }>;
+}
 export declare function createDefaultEnvironment(): Environment;
 export declare function createMemoryEnvironment(returnPathsRelativeTo?: string): {
     environment: Environment;
-    output: {
-        files: Record<string, string>;
-        deletedFiles: Array<string>;
-        commands: Array<{
-            command: string;
-            args: Array<string>;
-        }>;
-    };
+    output: MemoryEnvironmentOutput;
 };

package/dist/types/file-helpers.d.ts

@@ -4,6 +4,11 @@ export declare function isBinaryFile(path: string): boolean;
 export declare function convertBinaryContentsToBase64(contents: any): string;
 export declare function isBase64(content: string): boolean;
 export declare function getBinaryFile(content: string): string | null;
+/**
+ * Convert an absolute path to a clean relative path by removing a base directory.
+ * Returns a path without leading ./ or / prefix.
+ */
+export declare function toCleanPath(absolutePath: string, baseDir: string): string;
 export declare function relativePath(from: string, to: string, stripExtension?: boolean): string;
 export declare function isDirectory(path: string): boolean;
 export declare function findFilesRecursively(path: string, files: Record<string, string>): void;

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export { createApp } from './create-app.js';
+export { computeAttribution } from './attribution.js';
 export { addToApp } from './add-to-app.js';
-export { finalizeAddOns, getAllAddOns, populateAddOnOptionsDefaults } from './add-ons.js';
+export { finalizeAddOns, getAllAddOns, populateAddOnOptionsDefaults, } from './add-ons.js';
 export { loadRemoteAddOn } from './custom-add-ons/add-on.js';
 export { loadStarter } from './custom-add-ons/starter.js';
 export { createMemoryEnvironment, createDefaultEnvironment, } from './environment.js';
@@ -8,7 +9,7 @@ export { CONFIG_FILE } from './constants.js';
 export { DEFAULT_PACKAGE_MANAGER, SUPPORTED_PACKAGE_MANAGERS, getPackageManager, } from './package-manager.js';
 export { registerFramework, getFrameworkById, getFrameworkByName, getFrameworks, scanProjectDirectory, scanAddOnDirectories, } from './frameworks.js';
 export { writeConfigFileToEnvironment, readConfigFileFromEnvironment, readConfigFile, } from './config-file.js';
-export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, } from './file-helpers.js';
+export { cleanUpFiles, cleanUpFileArray, readFileHelper, getBinaryFile, recursivelyGatherFiles, relativePath, toCleanPath, } from './file-helpers.js';
 export { formatCommand, handleSpecialURL } from './utils.js';
 export { initStarter, compileStarter } from './custom-add-ons/starter.js';
 export { initAddOn, compileAddOn } from './custom-add-ons/add-on.js';
@@ -16,6 +17,8 @@ export { createAppOptionsFromPersisted, createSerializedOptionsFromPersisted, }
 export { createSerializedOptions } from './options.js';
 export { getRawRegistry, getRegistry, getRegistryAddOns, getRegistryStarters, } from './registry.js';
 export { StarterCompiledSchema, StatusEvent, StatusStepType, StopEvent, AddOnCompiledSchema, AddOnInfoSchema, IntegrationSchema, } from './types.js';
-export type { AddOn, AddOnOption, AddOnOptions, AddOnSelectOption, AddOnSelection, Environment, FileBundleHandler, Framework, FrameworkDefinition, Options, SerializedOptions, Starter, StarterCompiled, } from './types.js';
+export type { AddOn, AddOnOption, AddOnOptions, AddOnSelectOption, AddOnSelection, Environment, FileBundleHandler, Framework, FrameworkDefinition, Options, SerializedOptions, Starter, StarterCompiled, LineAttribution, FileProvenance, AttributedFile, DependencyAttribution, } from './types.js';
+export type { AttributionInput, AttributionOutput } from './attribution.js';
+export type { MemoryEnvironmentOutput } from './environment.js';
 export type { PersistedOptions } from './config-file.js';
 export type { PackageManager } from './package-manager.js';

package/dist/types/types.d.ts

@@ -114,6 +114,9 @@ export declare const AddOnBaseSchema: z.ZodObject<{
     warning: z.ZodOptional<z.ZodString>;
     tailwind: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     type: z.ZodEnum<["add-on", "example", "starter", "toolchain", "deployment"]>;
+    category: z.ZodOptional<z.ZodEnum<["tanstack", "database", "orm", "auth", "deploy", "styling", "monitoring", "cms", "api", "i18n", "tooling", "other"]>>;
+    exclusive: z.ZodOptional<z.ZodArray<z.ZodEnum<["orm", "auth", "deploy", "database", "linter"]>, "many">>;
+    color: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodNumber>;
     command: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -222,6 +225,9 @@ export declare const AddOnBaseSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -267,6 +273,9 @@ export declare const AddOnBaseSchema: z.ZodObject<{
     license?: string | undefined;
     warning?: string | undefined;
     tailwind?: boolean | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -297,6 +306,9 @@ export declare const StarterSchema: z.ZodObject<{
     license: z.ZodOptional<z.ZodString>;
     warning: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<["add-on", "example", "starter", "toolchain", "deployment"]>;
+    category: z.ZodOptional<z.ZodEnum<["tanstack", "database", "orm", "auth", "deploy", "styling", "monitoring", "cms", "api", "i18n", "tooling", "other"]>>;
+    exclusive: z.ZodOptional<z.ZodArray<z.ZodEnum<["orm", "auth", "deploy", "database", "linter"]>, "many">>;
+    color: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodNumber>;
     command: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -414,6 +426,9 @@ export declare const StarterSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -463,6 +478,9 @@ export declare const StarterSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -494,6 +512,9 @@ export declare const StarterCompiledSchema: z.ZodObject<{
     license: z.ZodOptional<z.ZodString>;
     warning: z.ZodOptional<z.ZodString>;
     type: z.ZodEnum<["add-on", "example", "starter", "toolchain", "deployment"]>;
+    category: z.ZodOptional<z.ZodEnum<["tanstack", "database", "orm", "auth", "deploy", "styling", "monitoring", "cms", "api", "i18n", "tooling", "other"]>>;
+    exclusive: z.ZodOptional<z.ZodArray<z.ZodEnum<["orm", "auth", "deploy", "database", "linter"]>, "many">>;
+    color: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodNumber>;
     command: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -616,6 +637,9 @@ export declare const StarterCompiledSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -667,6 +691,9 @@ export declare const StarterCompiledSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -718,6 +745,9 @@ export declare const AddOnInfoSchema: z.ZodObject<{
     warning: z.ZodOptional<z.ZodString>;
     tailwind: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     type: z.ZodEnum<["add-on", "example", "starter", "toolchain", "deployment"]>;
+    category: z.ZodOptional<z.ZodEnum<["tanstack", "database", "orm", "auth", "deploy", "styling", "monitoring", "cms", "api", "i18n", "tooling", "other"]>>;
+    exclusive: z.ZodOptional<z.ZodArray<z.ZodEnum<["orm", "auth", "deploy", "database", "linter"]>, "many">>;
+    color: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodNumber>;
     command: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -851,6 +881,9 @@ export declare const AddOnInfoSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -906,6 +939,9 @@ export declare const AddOnInfoSchema: z.ZodObject<{
     license?: string | undefined;
     warning?: string | undefined;
     tailwind?: boolean | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -945,6 +981,9 @@ export declare const AddOnCompiledSchema: z.ZodObject<{
     warning: z.ZodOptional<z.ZodString>;
     tailwind: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     type: z.ZodEnum<["add-on", "example", "starter", "toolchain", "deployment"]>;
+    category: z.ZodOptional<z.ZodEnum<["tanstack", "database", "orm", "auth", "deploy", "styling", "monitoring", "cms", "api", "i18n", "tooling", "other"]>>;
+    exclusive: z.ZodOptional<z.ZodArray<z.ZodEnum<["orm", "auth", "deploy", "database", "linter"]>, "many">>;
+    color: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodNumber>;
     command: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -1084,6 +1123,9 @@ export declare const AddOnCompiledSchema: z.ZodObject<{
     link?: string | undefined;
     license?: string | undefined;
     warning?: string | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -1142,6 +1184,9 @@ export declare const AddOnCompiledSchema: z.ZodObject<{
     license?: string | undefined;
     warning?: string | undefined;
     tailwind?: boolean | undefined;
+    category?: "other" | "tanstack" | "database" | "orm" | "auth" | "deploy" | "styling" | "monitoring" | "cms" | "api" | "i18n" | "tooling" | undefined;
+    exclusive?: ("database" | "orm" | "auth" | "deploy" | "linter")[] | undefined;
+    color?: string | undefined;
     priority?: number | undefined;
     routes?: {
         path: string;
@@ -1279,4 +1324,31 @@ type UIEnvironment = {
     confirm: (message: string) => Promise<boolean>;
 };
 export type Environment = ProjectEnvironment & FileEnvironment & UIEnvironment;
+export interface LineAttribution {
+    line: number;
+    sourceId: string;
+    sourceName: string;
+    type: 'original' | 'injected';
+}
+export interface FileProvenance {
+    source: 'framework' | 'add-on' | 'starter';
+    sourceId: string;
+    sourceName: string;
+}
+export interface AttributedFile {
+    content: string;
+    provenance: FileProvenance;
+    lineAttributions: Array<LineAttribution>;
+}
+export interface DependencyAttribution {
+    name: string;
+    version: string;
+    type: 'dependency' | 'devDependency';
+    sourceId: string;
+    sourceName: string;
+}
+export type IntegrationWithSource = Integration & {
+    _sourceId: string;
+    _sourceName: string;
+};
 export {};

package/dist/types.js

@@ -24,6 +24,26 @@ export const AddOnBaseSchema = z.object({
     warning: z.string().optional(),
     tailwind: z.boolean().optional().default(true),
     type: z.enum(['add-on', 'example', 'starter', 'toolchain', 'deployment']),
+    category: z
+        .enum([
+        'tanstack',
+        'database',
+        'orm',
+        'auth',
+        'deploy',
+        'styling',
+        'monitoring',
+        'cms',
+        'api',
+        'i18n',
+        'tooling',
+        'other',
+    ])
+        .optional(),
+    exclusive: z
+        .array(z.enum(['orm', 'auth', 'deploy', 'database', 'linter']))
+        .optional(),
+    color: z.string().optional(),
     priority: z.number().optional(),
     command: z
         .object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/cta-engine",
-  "version": "0.48.0",
+  "version": "0.49.1",
   "description": "Tanstack Application Builder Engine",
   "type": "module",
   "main": "./dist/index.js",