thomas-agentkit 0.4.0 → 0.5.0

package/README.md

@@ -66,6 +66,38 @@ Install stack-specific agent guidance:
 npx thomas-agentkit init --preset next
 ```
 
+Standardize install defaults with `agentkit.config.json`:
+
+```json
+{
+  "preset": "next",
+  "templateSet": "standard",
+  "designSystem": "linear",
+  "aiTools": ["codex", "cursor", "claude"],
+  "personalization": {
+    "projectName": "Acme CRM",
+    "projectDescription": "a customer operations dashboard",
+    "issueTracker": "Linear",
+    "designSystemPath": "docs/design-system.md",
+    "briefsPath": "docs/briefs",
+    "testCommand": "pnpm test",
+    "lintCommand": "pnpm lint",
+    "buildCommand": "pnpm build",
+    "stackSummary": "Next.js, TypeScript, PostgreSQL"
+  }
+}
+```
+
+AgentKit reads `agentkit.config.json` from the target directory first. When installing into another target that does not have a config file, it falls back to the current working directory. Config values are defaults: explicit CLI flags override them.
+
+Create a config file from resolved install choices:
+
+```bash
+npx thomas-agentkit init --write-config
+```
+
+`--write-config` writes `agentkit.config.json` in the target directory. Existing config files are skipped by default; use `--force` to overwrite one intentionally.
+
 List bundled templates:
 
 ```bash
@@ -78,6 +110,12 @@ List available presets:
 npx thomas-agentkit --list-presets
 ```
 
+List bundled design systems (source variants for `DESIGN-SYSTEM.md`):
+
+```bash
+npx thomas-agentkit --list-design-systems
+```
+
 ## Installed Files
 
 AgentKit copies these bundled files into the target project:
@@ -95,6 +133,8 @@ AgentKit copies these bundled files into the target project:
 
 When a preset is selected, AgentKit also installs `STACK.md` and adds a note in `AGENTS.md` telling agents to read it before changing stack-specific code.
 
+Bundled design system guidance is stored under `templates/design-systems/` in this repository (for example `linear.md`). The CLI installs the chosen variant into `DESIGN-SYSTEM.md` in the target project; variant paths are not separate install targets.
+
 Existing files are skipped by default so local edits are preserved. Use `--force` when you intentionally want to refresh files from the bundled package version.
 
 New installs wrap generated template content in AgentKit managed block markers:
@@ -109,6 +149,8 @@ Generated content
 
 Interactive personalization only applies during `agentkit init` when files are created or overwritten. It does not write a config file, and `agentkit update` does not reapply personalized values.
 
+`agentkit.config.json` can set `preset`, `templateSet`, `designSystem`, `aiTools`, and `personalization` defaults. `templateSet` may be `minimal`, `standard`, or `full`; `designSystem` selects which bundled design-system variant fills `DESIGN-SYSTEM.md` (currently `linear`); `aiTools` may include `codex`, `cursor`, `claude`, and `copilot`. `agentkit update` uses config `preset` and `designSystem` and continues to update all managed bundled templates.
+
 ## Presets
 
 Presets add stack-specific guidance without scaffolding framework app files.
@@ -122,10 +164,11 @@ Presets add stack-specific guidance without scaffolding framework app files.
 ## CLI Reference
 
 ```text
-agentkit init [target] [--force] [--dry-run] [--interactive] [--yes] [--preset <name>]
-agentkit update [target] [--dry-run] [--preset <name>]
+agentkit init [target] [--force] [--dry-run] [--interactive] [--yes] [--write-config] [--preset <name>] [--design-system <name>]
+agentkit update [target] [--dry-run] [--preset <name>] [--design-system <name>]
 agentkit --list
 agentkit --list-presets
+agentkit --list-design-systems
 agentkit --help
 agentkit --version
 ```
@@ -136,13 +179,16 @@ Options:
 - `--dry-run`: print planned changes without writing files
 - `-i, --interactive`: explicitly prompt for install options
 - `-y, --yes`: accept defaults without prompts
+- `--write-config`: write resolved install defaults to `agentkit.config.json`
 - `--preset <name>`: install stack-specific guidance (`next`, `sveltekit`, `express`, `convex`, `fullstack`)
+- `--design-system <name>`: design system variant for `DESIGN-SYSTEM.md` (`linear`)
 - `--list`: list bundled template files
 - `--list-presets`: list available presets
+- `--list-design-systems`: list available design systems
 - `-h, --help`: show help
 - `-v, --version`: show package version
 
-For `agentkit update`, `--preset <name>` refreshes preset-specific managed content, including `STACK.md`.
+For `agentkit update`, `--preset <name>` refreshes preset-specific managed content, including `STACK.md`. `--design-system <name>` refreshes the managed `DESIGN-SYSTEM.md` body from the matching bundled variant.
 
 ## Local Development
 

package/dist/cli.js

@@ -13,6 +13,24 @@ const packageJsonPath = path.join(packageRoot, "package.json");
 const validPresets = ["next", "sveltekit", "express", "convex", "fullstack"];
 const validProjectTypes = ["generic", ...validPresets];
 const validAiTools = ["codex", "cursor", "claude", "copilot"];
+const validTemplateSets = ["minimal", "standard", "full"];
+const validDesignSystems = ["linear"];
+const designSystemLabels = {
+    linear: "Linear-inspired",
+};
+const configFileName = "agentkit.config.json";
+const configKeys = ["preset", "templateSet", "aiTools", "designSystem", "personalization"];
+const personalizationKeys = [
+    "projectName",
+    "projectDescription",
+    "issueTracker",
+    "designSystemPath",
+    "briefsPath",
+    "testCommand",
+    "lintCommand",
+    "buildCommand",
+    "stackSummary",
+];
 const presetLabels = {
     next: "Next.js",
     sveltekit: "SvelteKit",
@@ -93,23 +111,35 @@ async function readPackageVersion() {
     const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
     return packageJson.version ?? "0.0.0";
 }
-async function getTemplateFiles(dir = templatesDir, base = templatesDir) {
+async function collectInstallableTemplatePaths(dir, base) {
     const dirStat = await stat(dir);
     if (!dirStat.isDirectory()) {
         throw new Error(`Bundled templates directory not found: ${templatesDir}`);
     }
     const entries = await readdir(dir, { withFileTypes: true });
-    const files = await Promise.all(entries.map(async (entry) => {
+    const discovered = [];
+    for (const entry of entries) {
         const absolutePath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            return getTemplateFiles(absolutePath, base);
+            if (dir === templatesDir && entry.name === "design-systems") {
+                continue;
+            }
+            discovered.push(...(await collectInstallableTemplatePaths(absolutePath, base)));
+            continue;
         }
         if (!entry.isFile()) {
-            return [];
+            continue;
         }
-        return [path.relative(base, absolutePath).split(path.sep).join("/")];
-    }));
-    return files.flat().sort();
+        discovered.push(path.relative(base, absolutePath).split(path.sep).join("/"));
+    }
+    return discovered;
+}
+async function getTemplateFiles() {
+    const discovered = await collectInstallableTemplatePaths(templatesDir, templatesDir);
+    const withDesignSystem = discovered.includes("DESIGN-SYSTEM.md")
+        ? discovered
+        : [...discovered, "DESIGN-SYSTEM.md"];
+    return withDesignSystem.sort();
 }
 function isPresetName(value) {
     return validPresets.includes(value);
@@ -120,9 +150,35 @@ function isProjectTypeName(value) {
 function isAiToolName(value) {
     return validAiTools.includes(value);
 }
+function isTemplateSetName(value) {
+    return validTemplateSets.includes(value);
+}
+function isDesignSystemName(value) {
+    return validDesignSystems.includes(value);
+}
 function formatPresetList() {
     return validPresets.join(", ");
 }
+function formatTemplateSetList() {
+    return validTemplateSets.join(", ");
+}
+function formatDesignSystemList() {
+    return validDesignSystems.join(", ");
+}
+function resolveDesignSystem(name) {
+    const normalized = name.toLowerCase();
+    if (!isDesignSystemName(normalized)) {
+        throw new Error(`Unknown design system "${name}". Valid design systems: ${formatDesignSystemList()}.`);
+    }
+    return normalized;
+}
+function effectiveDesignSystem(name) {
+    const trimmed = name?.trim();
+    if (!trimmed) {
+        return "linear";
+    }
+    return resolveDesignSystem(trimmed);
+}
 function resolvePreset(preset) {
     if (!preset) {
         return undefined;
@@ -133,6 +189,123 @@ function resolvePreset(preset) {
     }
     return normalizedPreset;
 }
+function resolveTemplateSet(templateSet) {
+    if (!templateSet) {
+        return undefined;
+    }
+    const normalizedTemplateSet = templateSet.toLowerCase();
+    if (!isTemplateSetName(normalizedTemplateSet)) {
+        throw new Error(`Unknown template set "${templateSet}". Valid template sets: ${formatTemplateSetList()}.`);
+    }
+    return normalizedTemplateSet;
+}
+function assertPlainObject(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${name} must be an object.`);
+    }
+}
+function assertKnownKeys(value, validKeys, name) {
+    for (const key of Object.keys(value)) {
+        if (!validKeys.includes(key)) {
+            throw new Error(`Unknown ${name} key "${key}". Valid keys: ${validKeys.join(", ")}.`);
+        }
+    }
+}
+function parseConfig(rawConfig, configPath) {
+    assertPlainObject(rawConfig, configFileName);
+    assertKnownKeys(rawConfig, configKeys, configFileName);
+    const config = {};
+    if (rawConfig.preset !== undefined) {
+        if (typeof rawConfig.preset !== "string") {
+            throw new Error(`${configFileName} preset must be a string.`);
+        }
+        config.preset = resolvePreset(rawConfig.preset);
+    }
+    if (rawConfig.templateSet !== undefined) {
+        if (typeof rawConfig.templateSet !== "string") {
+            throw new Error(`${configFileName} templateSet must be a string.`);
+        }
+        config.templateSet = resolveTemplateSet(rawConfig.templateSet);
+    }
+    if (rawConfig.aiTools !== undefined) {
+        if (!Array.isArray(rawConfig.aiTools)) {
+            throw new Error(`${configFileName} aiTools must be an array.`);
+        }
+        config.aiTools = rawConfig.aiTools.map((aiTool) => {
+            if (typeof aiTool !== "string" || !isAiToolName(aiTool)) {
+                throw new Error(`Unknown AI tool "${String(aiTool)}". Valid AI tools: ${validAiTools.join(", ")}.`);
+            }
+            return aiTool;
+        });
+    }
+    if (rawConfig.designSystem !== undefined) {
+        if (typeof rawConfig.designSystem !== "string") {
+            throw new Error(`${configFileName} designSystem must be a string.`);
+        }
+        config.designSystem = resolveDesignSystem(rawConfig.designSystem);
+    }
+    if (rawConfig.personalization !== undefined) {
+        assertPlainObject(rawConfig.personalization, `${configFileName} personalization`);
+        assertKnownKeys(rawConfig.personalization, personalizationKeys, `${configFileName} personalization`);
+        config.personalization = {};
+        for (const [key, value] of Object.entries(rawConfig.personalization)) {
+            if (typeof value !== "string") {
+                throw new Error(`${configFileName} personalization.${key} must be a string.`);
+            }
+            config.personalization[key] = value;
+        }
+    }
+    if (config.preset === undefined && rawConfig.preset !== undefined) {
+        throw new Error(`Invalid preset in ${configPath}.`);
+    }
+    return config;
+}
+async function readConfig(configPath) {
+    let rawContent;
+    try {
+        rawContent = await readFile(configPath, "utf8");
+    }
+    catch {
+        throw new Error(`Unable to read ${configPath}.`);
+    }
+    try {
+        return parseConfig(JSON.parse(rawContent), configPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${configPath}: ${message}`);
+    }
+}
+async function loadConfigForTarget(targetArg) {
+    const cwd = process.cwd();
+    const targetDir = path.resolve(cwd, targetArg || ".");
+    const targetConfigPath = path.join(targetDir, configFileName);
+    if (await exists(targetConfigPath)) {
+        return readConfig(targetConfigPath);
+    }
+    const cwdConfigPath = path.join(cwd, configFileName);
+    if (targetDir !== cwd && (await exists(cwdConfigPath))) {
+        return readConfig(cwdConfigPath);
+    }
+    return undefined;
+}
+async function applyInitConfig(options, config) {
+    if (!config) {
+        return;
+    }
+    options.preset ??= config.preset;
+    options.designSystem ??= config.designSystem;
+    options.personalization ??= config.personalization;
+    options.templateSet ??= config.templateSet;
+    options.aiTools ??= config.aiTools;
+}
+function applyUpdateConfig(options, config) {
+    if (!config) {
+        return;
+    }
+    options.preset ??= config.preset;
+    options.designSystem ??= config.designSystem;
+}
 export function resolveProjectPreset(projectType) {
     if (!projectType) {
         return undefined;
@@ -195,6 +368,33 @@ function cleanPersonalizationValue(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
 }
+function getResolvedConfig(options) {
+    const config = {
+        templateSet: options.templateSet ?? "full",
+        aiTools: options.aiTools ?? [],
+        designSystem: effectiveDesignSystem(options.designSystem),
+    };
+    const preset = resolvePreset(options.preset);
+    if (preset) {
+        config.preset = preset;
+    }
+    if (options.personalization) {
+        const personalization = {};
+        for (const key of personalizationKeys) {
+            const value = cleanPersonalizationValue(options.personalization[key]);
+            if (value) {
+                personalization[key] = value;
+            }
+        }
+        if (Object.keys(personalization).length > 0) {
+            config.personalization = personalization;
+        }
+    }
+    return config;
+}
+function serializeConfig(config) {
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
 function replaceIfProvided(content, placeholder, value) {
     const replacement = cleanPersonalizationValue(value);
     return replacement ? content.replaceAll(placeholder, replacement) : content;
@@ -282,10 +482,10 @@ export function personalizeTemplateContent(file, content, values) {
     }
     return personalized;
 }
-async function promptForPersonalization() {
+async function promptForPersonalization(defaults) {
     const shouldPersonalize = await confirm({
         message: "Personalize template placeholders?",
-        initialValue: false,
+        initialValue: Boolean(defaults),
     });
     if (isCancel(shouldPersonalize)) {
         process.exit(130);
@@ -296,6 +496,7 @@ async function promptForPersonalization() {
     const projectName = await text({
         message: "Project name",
         placeholder: "[Project Name]",
+        defaultValue: defaults?.projectName,
     });
     if (isCancel(projectName)) {
         process.exit(130);
@@ -303,6 +504,7 @@ async function promptForPersonalization() {
     const projectDescription = await text({
         message: "Short project description",
         placeholder: "[short project description]",
+        defaultValue: defaults?.projectDescription,
     });
     if (isCancel(projectDescription)) {
         process.exit(130);
@@ -310,6 +512,7 @@ async function promptForPersonalization() {
     const issueTracker = await text({
         message: "Issue tracker name",
         placeholder: "Linear or GitHub Issues",
+        defaultValue: defaults?.issueTracker,
     });
     if (isCancel(issueTracker)) {
         process.exit(130);
@@ -317,6 +520,7 @@ async function promptForPersonalization() {
     const designSystemPath = await text({
         message: "Design system path",
         placeholder: "docs/design-system.md",
+        defaultValue: defaults?.designSystemPath,
     });
     if (isCancel(designSystemPath)) {
         process.exit(130);
@@ -324,6 +528,7 @@ async function promptForPersonalization() {
     const briefsPath = await text({
         message: "Briefs path",
         placeholder: "docs/briefs",
+        defaultValue: defaults?.briefsPath,
     });
     if (isCancel(briefsPath)) {
         process.exit(130);
@@ -331,6 +536,7 @@ async function promptForPersonalization() {
     const testCommand = await text({
         message: "Test command",
         placeholder: "npm test",
+        defaultValue: defaults?.testCommand,
     });
     if (isCancel(testCommand)) {
         process.exit(130);
@@ -338,6 +544,7 @@ async function promptForPersonalization() {
     const lintCommand = await text({
         message: "Lint command",
         placeholder: "npm run lint",
+        defaultValue: defaults?.lintCommand,
     });
     if (isCancel(lintCommand)) {
         process.exit(130);
@@ -345,6 +552,7 @@ async function promptForPersonalization() {
     const buildCommand = await text({
         message: "Build/check command",
         placeholder: "npm run build",
+        defaultValue: defaults?.buildCommand,
     });
     if (isCancel(buildCommand)) {
         process.exit(130);
@@ -352,6 +560,7 @@ async function promptForPersonalization() {
     const stackSummary = await text({
         message: "Stack summary",
         placeholder: "Next.js, TypeScript, Tailwind CSS, Vitest",
+        defaultValue: defaults?.stackSummary,
     });
     if (isCancel(stackSummary)) {
         process.exit(130);
@@ -368,19 +577,37 @@ async function promptForPersonalization() {
         stackSummary,
     };
 }
-async function buildInitTemplateContent(file, preset, personalization) {
-    const content = await buildTemplateContent(file, preset);
+async function buildInitTemplateContent(file, preset, personalization, designSystem) {
+    const content = await buildTemplateContent(file, preset, designSystem);
     return personalizeTemplateContent(file, content, personalization);
 }
 async function installTemplates(targetArg, options) {
     const targetDir = path.resolve(process.cwd(), targetArg || ".");
-    const files = options.files ?? (await getTemplateFiles());
+    const allTemplateFiles = await getTemplateFiles();
+    const files = options.files ??
+        (options.templateSet || options.aiTools
+            ? getSelectedTemplateFiles(options.templateSet ?? "full", options.aiTools ?? [], allTemplateFiles)
+            : allTemplateFiles);
     const preset = resolvePreset(options.preset);
+    const designSystem = effectiveDesignSystem(options.designSystem);
     const created = [];
     const skipped = [];
     if (!options.dryRun) {
         await mkdir(targetDir, { recursive: true });
     }
+    if (options.writeConfig) {
+        const destination = path.join(targetDir, configFileName);
+        const destinationExists = await exists(destination);
+        if (destinationExists && !options.force) {
+            skipped.push(configFileName);
+        }
+        else {
+            created.push(configFileName);
+            if (!options.dryRun) {
+                await writeFile(destination, serializeConfig(getResolvedConfig(options)));
+            }
+        }
+    }
     for (const file of files) {
         const destination = path.join(targetDir, file);
         const destinationExists = await exists(destination);
@@ -391,14 +618,8 @@ async function installTemplates(targetArg, options) {
         created.push(file);
         if (!options.dryRun) {
             await mkdir(path.dirname(destination), { recursive: true });
-            if (preset && file === "AGENTS.md") {
-                const content = await buildInitTemplateContent(file, preset, options.personalization);
-                await writeFile(destination, wrapManagedBlock(file, content));
-            }
-            else {
-                const content = await buildInitTemplateContent(file, preset, options.personalization);
-                await writeFile(destination, wrapManagedBlock(file, content));
-            }
+            const content = await buildInitTemplateContent(file, preset, options.personalization, designSystem);
+            await writeFile(destination, wrapManagedBlock(file, content));
         }
     }
     if (preset) {
@@ -433,13 +654,18 @@ function replaceManagedBlock(file, existingContent, nextContent) {
     const replacement = wrapManagedBlock(file, nextContent).trimEnd();
     return `${existingContent.slice(0, startIndex)}${replacement}${existingContent.slice(afterEndIndex)}`;
 }
-async function buildTemplateContent(file, preset) {
+async function buildTemplateContent(file, preset, designSystem) {
     if (file === "STACK.md") {
         if (!preset) {
             throw new Error("STACK.md requires a preset.");
         }
         return getStackGuidance(preset);
     }
+    if (file === "DESIGN-SYSTEM.md") {
+        const source = path.join(templatesDir, "design-systems", `${designSystem}.md`);
+        const content = await readFile(source, "utf8");
+        return addStackReference(file, content, preset);
+    }
     const source = path.join(templatesDir, file);
     const content = await readFile(source, "utf8");
     return addStackReference(file, content, preset);
@@ -447,6 +673,7 @@ async function buildTemplateContent(file, preset) {
 async function updateTemplates(targetArg, options) {
     const targetDir = path.resolve(process.cwd(), targetArg || ".");
     const preset = resolvePreset(options.preset);
+    const designSystem = effectiveDesignSystem(options.designSystem);
     const files = preset ? [...(await getTemplateFiles()), "STACK.md"] : await getTemplateFiles();
     const created = [];
     const updated = [];
@@ -455,7 +682,7 @@ async function updateTemplates(targetArg, options) {
     const unchanged = [];
     for (const file of files) {
         const destination = path.join(targetDir, file);
-        const nextContent = await buildTemplateContent(file, preset);
+        const nextContent = await buildTemplateContent(file, preset, designSystem);
         const destinationExists = await exists(destination);
         if (!destinationExists) {
             created.push(file);
@@ -569,7 +796,7 @@ async function resolveInteractiveTarget(target, options) {
     }
     const aiToolResponse = await multiselect({
         message: "Which AI tools do you use?",
-        initialValues: ["codex", "cursor", "claude"],
+        initialValues: options.aiTools ?? ["codex", "cursor", "claude"],
         options: [
             { label: "Codex", value: "codex" },
             { label: "Cursor", value: "cursor" },
@@ -582,7 +809,7 @@ async function resolveInteractiveTarget(target, options) {
     }
     const templateSetResponse = await select({
         message: "Which template set do you want?",
-        initialValue: "standard",
+        initialValue: options.templateSet ?? "standard",
         options: [
             { label: "Minimal", value: "minimal" },
             { label: "Standard", value: "standard" },
@@ -593,7 +820,20 @@ async function resolveInteractiveTarget(target, options) {
         process.exit(130);
     }
     const templateFiles = await getTemplateFiles();
+    options.templateSet = templateSetResponse;
+    options.aiTools = aiToolResponse;
     options.files = getSelectedTemplateFiles(templateSetResponse, aiToolResponse, templateFiles);
+    if (templateSetResponse === "standard" || templateSetResponse === "full") {
+        const designSystemResponse = await select({
+            message: "Which design system guidance?",
+            initialValue: effectiveDesignSystem(options.designSystem),
+            options: validDesignSystems.map((value) => ({ label: designSystemLabels[value], value })),
+        });
+        if (isCancel(designSystemResponse)) {
+            process.exit(130);
+        }
+        options.designSystem = designSystemResponse;
+    }
     if (!options.force) {
         const preset = resolvePreset(options.preset);
         const installFiles = preset ? [...options.files, "STACK.md"] : options.files;
@@ -619,7 +859,7 @@ async function resolveInteractiveTarget(target, options) {
             options.force = conflictResponse === "overwrite";
         }
     }
-    options.personalization = await promptForPersonalization();
+    options.personalization = await promptForPersonalization(options.personalization);
     return resolvedTarget || ".";
 }
 async function main() {
@@ -636,6 +876,12 @@ async function main() {
         }
         return;
     }
+    if (process.argv.slice(2).includes("--list-design-systems")) {
+        for (const designSystem of validDesignSystems) {
+            console.log(designSystem);
+        }
+        return;
+    }
     const program = new Command();
     program
         .name("agentkit")
@@ -643,6 +889,7 @@ async function main() {
         .version(await readPackageVersion(), "-v, --version")
         .option("--list", "list bundled template files")
         .option("--list-presets", "list available presets")
+        .option("--list-design-systems", "list available design systems")
         .addHelpText("after", `
 
 Examples:
@@ -651,6 +898,7 @@ Examples:
   agentkit init --preset next
   agentkit init ./my-project --yes --dry-run
   agentkit --list-presets
+  agentkit --list-design-systems
   agentkit --list`);
     program
         .command("init")
@@ -660,8 +908,11 @@ Examples:
         .option("--dry-run", "print planned changes without writing files")
         .option("-i, --interactive", "prompt for install options")
         .option("-y, --yes", "accept defaults for non-interactive runs")
+        .option("--write-config", "write resolved install defaults to agentkit.config.json")
         .option("--preset <name>", `install stack-specific guidance (${formatPresetList()})`)
+        .option("--design-system <name>", `design system guidance for DESIGN-SYSTEM.md (${formatDesignSystemList()})`)
         .action(async (target, options) => {
+        await applyInitConfig(options, await loadConfigForTarget(target));
         const resolvedTarget = await resolveInteractiveTarget(target, options);
         const result = await installTemplates(resolvedTarget, options);
         printInstallResult(result, Boolean(options.dryRun));
@@ -672,7 +923,9 @@ Examples:
         .argument("[target]", "target project directory", ".")
         .option("--dry-run", "print planned changes without writing files")
         .option("--preset <name>", `update stack-specific guidance (${formatPresetList()})`)
+        .option("--design-system <name>", `design system guidance for DESIGN-SYSTEM.md (${formatDesignSystemList()})`)
         .action(async (target, options) => {
+        applyUpdateConfig(options, await loadConfigForTarget(target));
         const result = await updateTemplates(target, options);
         printUpdateResult(result, Boolean(options.dryRun));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thomas-agentkit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Install AI-agent-ready development templates into a project.",
   "license": "MIT",
   "repository": {