thomas-agentkit 0.2.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Howard Thomas
+
+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

@@ -14,16 +14,26 @@ Install templates into the current directory:
 npx thomas-agentkit init
 ```
 
+By default, `init` opens a short interactive setup flow in terminals. After choosing install options, you can optionally personalize repository-level template placeholders such as project name, description, issue tracker, docs paths, stack summary, and project commands.
+
 Install into another directory:
 
 ```bash
 npx thomas-agentkit init ./my-project
 ```
 
+Accept defaults without prompts:
+
+```bash
+npx thomas-agentkit init --yes
+```
+
+`--yes` keeps installed templates generic and leaves placeholders for later editing.
+
 Preview changes without writing files:
 
 ```bash
-npx thomas-agentkit init --dry-run
+npx thomas-agentkit init --yes --dry-run
 ```
 
 Overwrite existing files:
@@ -32,7 +42,19 @@ Overwrite existing files:
 npx thomas-agentkit init --force
 ```
 
-Use the optional interactive flow:
+Update AgentKit-managed template sections:
+
+```bash
+npx thomas-agentkit update
+```
+
+Preview updates without writing files:
+
+```bash
+npx thomas-agentkit update --dry-run
+```
+
+Explicitly request the interactive flow:
 
 ```bash
 npx thomas-agentkit init --interactive
@@ -75,6 +97,18 @@ When a preset is selected, AgentKit also installs `STACK.md` and adds a note in
 
 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:
+
+```html
+<!-- agentkit:start agents -->
+Generated content
+<!-- agentkit:end agents -->
+```
+
+`agentkit update` only replaces content inside matching managed blocks. User edits before or after those blocks are preserved. Existing legacy files without managed blocks are reported as unmanaged and left untouched.
+
+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.
+
 ## Presets
 
 Presets add stack-specific guidance without scaffolding framework app files.
@@ -89,6 +123,7 @@ Presets add stack-specific guidance without scaffolding framework app files.
 
 ```text
 agentkit init [target] [--force] [--dry-run] [--interactive] [--yes] [--preset <name>]
+agentkit update [target] [--dry-run] [--preset <name>]
 agentkit --list
 agentkit --list-presets
 agentkit --help
@@ -99,25 +134,56 @@ Options:
 
 - `--force`: overwrite existing files
 - `--dry-run`: print planned changes without writing files
-- `-i, --interactive`: prompt for install options
-- `-y, --yes`: accept defaults for non-interactive runs
+- `-i, --interactive`: explicitly prompt for install options
+- `-y, --yes`: accept defaults without prompts
 - `--preset <name>`: install stack-specific guidance (`next`, `sveltekit`, `express`, `convex`, `fullstack`)
 - `--list`: list bundled template files
 - `--list-presets`: list available presets
 - `-h, --help`: show help
 - `-v, --version`: show package version
 
+For `agentkit update`, `--preset <name>` refreshes preset-specific managed content, including `STACK.md`.
+
 ## Local Development
 
 ```bash
 npm install
-npm run dev -- init ./tmp-demo --dry-run
+npm run dev -- init ./tmp-demo --yes --dry-run
 npm run build
 npm test
 ```
 
 The npm package is `thomas-agentkit`. The installed CLI command is `agentkit`, backed by the compiled TypeScript entrypoint at `dist/cli.js`.
 
+## Release
+
+Before publishing a new package version:
+
+1. Update the version in `package.json` intentionally.
+2. Run the full test suite:
+
+   ```bash
+   npm test
+   ```
+
+3. Run the package build step:
+
+   ```bash
+   npm run prepack
+   ```
+
+4. Inspect the publish contents:
+
+   ```bash
+   npm pack --dry-run
+   ```
+
+5. Publish to npm:
+
+   ```bash
+   npm publish
+   ```
+
 ## Philosophy
 
 AgentKit should stay:

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { confirm, isCancel, select, text } from "@clack/prompts";
+import { confirm, intro, isCancel, multiselect, select, text } from "@clack/prompts";
 import { Command } from "commander";
 import { constants as fsConstants } from "node:fs";
-import { access, copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { access, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
@@ -11,6 +11,8 @@ const packageRoot = path.resolve(__dirname, "..");
 const templatesDir = path.join(packageRoot, "templates");
 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 presetLabels = {
     next: "Next.js",
     sveltekit: "SvelteKit",
@@ -18,6 +20,17 @@ const presetLabels = {
     convex: "Convex",
     fullstack: "Fullstack",
 };
+const aiToolFiles = {
+    codex: ["AGENTS.md"],
+    cursor: [".cursor/rules/agentkit.md"],
+    claude: ["CLAUDE.md"],
+    copilot: [".github/copilot-instructions.md"],
+};
+const templateSetFiles = {
+    minimal: ["AGENTS.md"],
+    standard: ["AGENTS.md", "CODE-QUALITY.md", "DESIGN-SYSTEM.md", "WORKFLOWS.md"],
+    full: [],
+};
 const stackGuidance = {
     next: `# Stack Guidance
 
@@ -101,6 +114,12 @@ async function getTemplateFiles(dir = templatesDir, base = templatesDir) {
 function isPresetName(value) {
     return validPresets.includes(value);
 }
+function isProjectTypeName(value) {
+    return validProjectTypes.includes(value);
+}
+function isAiToolName(value) {
+    return validAiTools.includes(value);
+}
 function formatPresetList() {
     return validPresets.join(", ");
 }
@@ -114,9 +133,54 @@ function resolvePreset(preset) {
     }
     return normalizedPreset;
 }
+export function resolveProjectPreset(projectType) {
+    if (!projectType) {
+        return undefined;
+    }
+    const normalizedProjectType = projectType.toLowerCase();
+    if (!isProjectTypeName(normalizedProjectType)) {
+        throw new Error(`Unknown project type "${projectType}". Valid project types: ${validProjectTypes.join(", ")}.`);
+    }
+    return normalizedProjectType === "generic" ? undefined : normalizedProjectType;
+}
+export function getFilesForAiTools(aiTools) {
+    const files = new Set();
+    for (const aiTool of aiTools) {
+        if (!isAiToolName(aiTool)) {
+            throw new Error(`Unknown AI tool "${aiTool}". Valid AI tools: ${validAiTools.join(", ")}.`);
+        }
+        for (const file of aiToolFiles[aiTool]) {
+            files.add(file);
+        }
+    }
+    return [...files].sort();
+}
+export function getFilesForTemplateSet(templateSet, allTemplateFiles) {
+    if (templateSet === "full") {
+        return [...allTemplateFiles].sort();
+    }
+    return templateSetFiles[templateSet].filter((file) => allTemplateFiles.includes(file)).sort();
+}
+export function getSelectedTemplateFiles(templateSet, aiTools, allTemplateFiles) {
+    const files = new Set([...getFilesForTemplateSet(templateSet, allTemplateFiles), ...getFilesForAiTools(aiTools)]);
+    return [...files].filter((file) => allTemplateFiles.includes(file)).sort();
+}
 function getStackGuidance(preset) {
     return preset === "fullstack" ? fullstackGuidance : stackGuidance[preset];
 }
+function getTemplateId(file) {
+    return file
+        .replace(/\.[^/.]+$/, "")
+        .replace(/^\./, "")
+        .split("/")
+        .filter(Boolean)
+        .join("-")
+        .toLowerCase();
+}
+function wrapManagedBlock(file, content) {
+    const id = getTemplateId(file);
+    return `<!-- agentkit:start ${id} -->\n${content.trimEnd()}\n<!-- agentkit:end ${id} -->\n`;
+}
 function addStackReference(file, content, preset) {
     if (file !== "AGENTS.md" || !preset) {
         return content;
@@ -127,9 +191,190 @@ function addStackReference(file, content, preset) {
     }
     return `${content.trimEnd()}\n${stackNote}`;
 }
+function cleanPersonalizationValue(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function replaceIfProvided(content, placeholder, value) {
+    const replacement = cleanPersonalizationValue(value);
+    return replacement ? content.replaceAll(placeholder, replacement) : content;
+}
+function getProvidedCommands(values) {
+    return [values.testCommand, values.lintCommand, values.buildCommand]
+        .map(cleanPersonalizationValue)
+        .filter((command) => Boolean(command));
+}
+function commandDescription(command, kind) {
+    const descriptions = {
+        test: "Run tests",
+        lint: "Run lint checks",
+        build: "Build or check the project",
+    };
+    return descriptions[kind] ?? command;
+}
+function replaceCommandBlock(content, commands) {
+    if (commands.length === 0) {
+        return content;
+    }
+    const commandBlock = ["```bash", ...commands, "```"].join("\n");
+    return content
+        .replace(/```bash\nnpm install\nnpm test\nnpm run build\nnpm run lint\n```/, commandBlock)
+        .replace(/```bash\nnpm test\nnpm run lint\nnpm run build\n```/, commandBlock);
+}
+function replaceAgentCommandTable(content, values) {
+    const rows = [
+        cleanPersonalizationValue(values.testCommand)
+            ? `| \`${cleanPersonalizationValue(values.testCommand)}\` | ${commandDescription(values.testCommand ?? "", "test")} |`
+            : undefined,
+        cleanPersonalizationValue(values.lintCommand)
+            ? `| \`${cleanPersonalizationValue(values.lintCommand)}\` | ${commandDescription(values.lintCommand ?? "", "lint")} |`
+            : undefined,
+        cleanPersonalizationValue(values.buildCommand)
+            ? `| \`${cleanPersonalizationValue(values.buildCommand)}\` | ${commandDescription(values.buildCommand ?? "", "build")} |`
+            : undefined,
+    ].filter((row) => Boolean(row));
+    if (rows.length === 0) {
+        return content;
+    }
+    const nextTable = ["| Command | Description |", "| --- | --- |", ...rows].join("\n");
+    return content.replace(/\| Command \| Description \|\n\| --- \| --- \|\n\| `npm run dev` \| Start the local development server \|\n\| `npm test` \| Run tests \|\n\| `npm run lint` \| Run lint checks \|\n\| `npm run build` \| Build the project \|/, nextTable);
+}
+function replaceStackSummary(content, stackSummary) {
+    const summary = cleanPersonalizationValue(stackSummary);
+    if (!summary) {
+        return content;
+    }
+    const stackItems = summary
+        .split(/\r?\n|,/)
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map((item) => `- ${item}`)
+        .join("\n");
+    return content.replace(/- \[Primary framework\]\n- \[Language\/runtime\]\n- \[Backend\/data layer\]\n- \[Styling system\]\n- \[Test tools\]\n- \[Lint\/format tools\]/, stackItems);
+}
+export function personalizeTemplateContent(file, content, values) {
+    if (!values) {
+        return content;
+    }
+    if (file === "PRD-TEMPLATE.md" ||
+        file === "IMPLEMENTATION-BRIEF-TEMPLATE.md" ||
+        file === ".github/pull_request_template.md") {
+        return content;
+    }
+    let personalized = content;
+    if (file === "AGENTS.md" || file === "DESIGN-SYSTEM.md") {
+        personalized = replaceIfProvided(personalized, "[Project Name]", values.projectName);
+    }
+    if (file === "AGENTS.md") {
+        personalized = replaceIfProvided(personalized, "[short project description]", values.projectDescription);
+        personalized = replaceIfProvided(personalized, "[issue tracker, e.g. Linear or GitHub Issues]", values.issueTracker);
+        personalized = replaceIfProvided(personalized, "[design system path, e.g. docs/design-system.md]", values.designSystemPath);
+        personalized = replaceIfProvided(personalized, "[design system path]", values.designSystemPath);
+        personalized = replaceIfProvided(personalized, "[briefs path, e.g. docs/briefs]", values.briefsPath);
+        personalized = replaceIfProvided(personalized, "[test command, e.g. npm test]", values.testCommand);
+        personalized = replaceIfProvided(personalized, "[lint command, e.g. npm run lint]", values.lintCommand);
+        personalized = replaceIfProvided(personalized, "[build/check command, e.g. npm run build]", values.buildCommand);
+        personalized = replaceAgentCommandTable(personalized, values);
+        personalized = replaceStackSummary(personalized, values.stackSummary);
+    }
+    if (file === "CLAUDE.md" || file === "CODE-QUALITY.md") {
+        personalized = replaceCommandBlock(personalized, getProvidedCommands(values));
+    }
+    return personalized;
+}
+async function promptForPersonalization() {
+    const shouldPersonalize = await confirm({
+        message: "Personalize template placeholders?",
+        initialValue: false,
+    });
+    if (isCancel(shouldPersonalize)) {
+        process.exit(130);
+    }
+    if (!shouldPersonalize) {
+        return undefined;
+    }
+    const projectName = await text({
+        message: "Project name",
+        placeholder: "[Project Name]",
+    });
+    if (isCancel(projectName)) {
+        process.exit(130);
+    }
+    const projectDescription = await text({
+        message: "Short project description",
+        placeholder: "[short project description]",
+    });
+    if (isCancel(projectDescription)) {
+        process.exit(130);
+    }
+    const issueTracker = await text({
+        message: "Issue tracker name",
+        placeholder: "Linear or GitHub Issues",
+    });
+    if (isCancel(issueTracker)) {
+        process.exit(130);
+    }
+    const designSystemPath = await text({
+        message: "Design system path",
+        placeholder: "docs/design-system.md",
+    });
+    if (isCancel(designSystemPath)) {
+        process.exit(130);
+    }
+    const briefsPath = await text({
+        message: "Briefs path",
+        placeholder: "docs/briefs",
+    });
+    if (isCancel(briefsPath)) {
+        process.exit(130);
+    }
+    const testCommand = await text({
+        message: "Test command",
+        placeholder: "npm test",
+    });
+    if (isCancel(testCommand)) {
+        process.exit(130);
+    }
+    const lintCommand = await text({
+        message: "Lint command",
+        placeholder: "npm run lint",
+    });
+    if (isCancel(lintCommand)) {
+        process.exit(130);
+    }
+    const buildCommand = await text({
+        message: "Build/check command",
+        placeholder: "npm run build",
+    });
+    if (isCancel(buildCommand)) {
+        process.exit(130);
+    }
+    const stackSummary = await text({
+        message: "Stack summary",
+        placeholder: "Next.js, TypeScript, Tailwind CSS, Vitest",
+    });
+    if (isCancel(stackSummary)) {
+        process.exit(130);
+    }
+    return {
+        projectName,
+        projectDescription,
+        issueTracker,
+        designSystemPath,
+        briefsPath,
+        testCommand,
+        lintCommand,
+        buildCommand,
+        stackSummary,
+    };
+}
+async function buildInitTemplateContent(file, preset, personalization) {
+    const content = await buildTemplateContent(file, preset);
+    return personalizeTemplateContent(file, content, personalization);
+}
 async function installTemplates(targetArg, options) {
     const targetDir = path.resolve(process.cwd(), targetArg || ".");
-    const files = await getTemplateFiles();
+    const files = options.files ?? (await getTemplateFiles());
     const preset = resolvePreset(options.preset);
     const created = [];
     const skipped = [];
@@ -137,7 +382,6 @@ async function installTemplates(targetArg, options) {
         await mkdir(targetDir, { recursive: true });
     }
     for (const file of files) {
-        const source = path.join(templatesDir, file);
         const destination = path.join(targetDir, file);
         const destinationExists = await exists(destination);
         if (destinationExists && !options.force) {
@@ -148,11 +392,12 @@ async function installTemplates(targetArg, options) {
         if (!options.dryRun) {
             await mkdir(path.dirname(destination), { recursive: true });
             if (preset && file === "AGENTS.md") {
-                const content = await readFile(source, "utf8");
-                await writeFile(destination, addStackReference(file, content, preset));
+                const content = await buildInitTemplateContent(file, preset, options.personalization);
+                await writeFile(destination, wrapManagedBlock(file, content));
             }
             else {
-                await copyFile(source, destination);
+                const content = await buildInitTemplateContent(file, preset, options.personalization);
+                await writeFile(destination, wrapManagedBlock(file, content));
             }
         }
     }
@@ -166,12 +411,84 @@ async function installTemplates(targetArg, options) {
         else {
             created.push(stackFile);
             if (!options.dryRun) {
-                await writeFile(destination, getStackGuidance(preset));
+                await writeFile(destination, wrapManagedBlock(stackFile, getStackGuidance(preset)));
             }
         }
     }
     return { targetDir, created, skipped };
 }
+function replaceManagedBlock(file, existingContent, nextContent) {
+    const id = getTemplateId(file);
+    const startMarker = `<!-- agentkit:start ${id} -->`;
+    const endMarker = `<!-- agentkit:end ${id} -->`;
+    const startIndex = existingContent.indexOf(startMarker);
+    const endIndex = existingContent.indexOf(endMarker);
+    if (startIndex === -1 && endIndex === -1) {
+        return undefined;
+    }
+    if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+        throw new Error(`Malformed managed block in ${file}.`);
+    }
+    const afterEndIndex = endIndex + endMarker.length;
+    const replacement = wrapManagedBlock(file, nextContent).trimEnd();
+    return `${existingContent.slice(0, startIndex)}${replacement}${existingContent.slice(afterEndIndex)}`;
+}
+async function buildTemplateContent(file, preset) {
+    if (file === "STACK.md") {
+        if (!preset) {
+            throw new Error("STACK.md requires a preset.");
+        }
+        return getStackGuidance(preset);
+    }
+    const source = path.join(templatesDir, file);
+    const content = await readFile(source, "utf8");
+    return addStackReference(file, content, preset);
+}
+async function updateTemplates(targetArg, options) {
+    const targetDir = path.resolve(process.cwd(), targetArg || ".");
+    const preset = resolvePreset(options.preset);
+    const files = preset ? [...(await getTemplateFiles()), "STACK.md"] : await getTemplateFiles();
+    const created = [];
+    const updated = [];
+    const skipped = [];
+    const malformed = [];
+    const unchanged = [];
+    for (const file of files) {
+        const destination = path.join(targetDir, file);
+        const nextContent = await buildTemplateContent(file, preset);
+        const destinationExists = await exists(destination);
+        if (!destinationExists) {
+            created.push(file);
+            if (!options.dryRun) {
+                await mkdir(path.dirname(destination), { recursive: true });
+                await writeFile(destination, wrapManagedBlock(file, nextContent));
+            }
+            continue;
+        }
+        const existingContent = await readFile(destination, "utf8");
+        let updatedContent;
+        try {
+            updatedContent = replaceManagedBlock(file, existingContent, nextContent);
+        }
+        catch {
+            malformed.push(file);
+            continue;
+        }
+        if (updatedContent === undefined) {
+            skipped.push(file);
+            continue;
+        }
+        if (updatedContent === existingContent) {
+            unchanged.push(file);
+            continue;
+        }
+        updated.push(file);
+        if (!options.dryRun) {
+            await writeFile(destination, updatedContent);
+        }
+    }
+    return { targetDir, created, updated, skipped, malformed, unchanged };
+}
 function printInstallResult(result, dryRun = false) {
     const action = dryRun ? "Would install" : "Installed";
     console.log(`${action} AgentKit files in ${result.targetDir}`);
@@ -186,44 +503,124 @@ function printInstallResult(result, dryRun = false) {
         console.log("No bundled templates found.");
     }
 }
+function printUpdateResult(result, dryRun = false) {
+    const action = dryRun ? "Would update" : "Updated";
+    console.log(`${action} AgentKit files in ${result.targetDir}`);
+    if (result.created.length > 0) {
+        console.log(`${dryRun ? "Would create" : "Created"}: ${result.created.join(", ")}`);
+    }
+    if (result.updated.length > 0) {
+        console.log(`${dryRun ? "Would update" : "Updated"}: ${result.updated.join(", ")}`);
+    }
+    if (result.unchanged.length > 0) {
+        console.log(`Already current: ${result.unchanged.join(", ")}`);
+    }
+    if (result.skipped.length > 0) {
+        console.log(`Skipped unmanaged: ${result.skipped.join(", ")}`);
+        console.log("Add AgentKit managed block markers before updating these files.");
+    }
+    if (result.malformed.length > 0) {
+        console.log(`Skipped malformed: ${result.malformed.join(", ")}`);
+        console.log("Fix AgentKit managed block markers before updating these files.");
+    }
+    if (result.created.length === 0 &&
+        result.updated.length === 0 &&
+        result.skipped.length === 0 &&
+        result.malformed.length === 0) {
+        console.log("All managed AgentKit files are current.");
+    }
+}
 async function resolveInteractiveTarget(target, options) {
     const providedPreset = resolvePreset(options.preset);
-    if (!options.interactive) {
+    const shouldPrompt = !options.yes && (options.interactive || process.stdin.isTTY);
+    if (!shouldPrompt) {
         return target;
     }
-    const targetResponse = await text({
-        message: "Where should AgentKit install templates?",
-        placeholder: target || ".",
-        defaultValue: target || ".",
-    });
-    if (isCancel(targetResponse)) {
-        process.exit(130);
+    intro("Welcome to AgentKit");
+    let resolvedTarget = target;
+    if (!target || target === ".") {
+        const targetResponse = await text({
+            message: "Where should AgentKit install files?",
+            placeholder: ".",
+            defaultValue: ".",
+        });
+        if (isCancel(targetResponse)) {
+            process.exit(130);
+        }
+        resolvedTarget = targetResponse || ".";
     }
-    const forceResponse = await confirm({
-        message: "Overwrite existing files?",
-        initialValue: Boolean(options.force),
+    if (!providedPreset) {
+        const projectTypeResponse = await select({
+            message: "What type of project is this?",
+            initialValue: "generic",
+            options: [
+                { label: "Generic TypeScript project", value: "generic" },
+                { label: "Next.js app", value: "next" },
+                { label: "SvelteKit app", value: "sveltekit" },
+                { label: "Express API", value: "express" },
+                { label: "Convex app", value: "convex" },
+                { label: "Fullstack app", value: "fullstack" },
+            ],
+        });
+        if (isCancel(projectTypeResponse)) {
+            process.exit(130);
+        }
+        options.preset = resolveProjectPreset(projectTypeResponse);
+    }
+    const aiToolResponse = await multiselect({
+        message: "Which AI tools do you use?",
+        initialValues: ["codex", "cursor", "claude"],
+        options: [
+            { label: "Codex", value: "codex" },
+            { label: "Cursor", value: "cursor" },
+            { label: "Claude Code", value: "claude" },
+            { label: "GitHub Copilot", value: "copilot" },
+        ],
     });
-    if (isCancel(forceResponse)) {
+    if (isCancel(aiToolResponse)) {
         process.exit(130);
     }
-    const presetResponse = await select({
-        message: "Which preset should AgentKit use?",
-        initialValue: providedPreset || "generic",
+    const templateSetResponse = await select({
+        message: "Which template set do you want?",
+        initialValue: "standard",
         options: [
-            { label: "Generic", value: "generic" },
-            { label: "Next.js", value: "next" },
-            { label: "SvelteKit", value: "sveltekit" },
-            { label: "Express", value: "express" },
-            { label: "Convex", value: "convex" },
-            { label: "Fullstack", value: "fullstack" },
+            { label: "Minimal", value: "minimal" },
+            { label: "Standard", value: "standard" },
+            { label: "Full", value: "full" },
         ],
     });
-    if (isCancel(presetResponse)) {
+    if (isCancel(templateSetResponse)) {
         process.exit(130);
     }
-    options.preset = presetResponse === "generic" ? undefined : presetResponse;
-    options.force = forceResponse;
-    return targetResponse || ".";
+    const templateFiles = await getTemplateFiles();
+    options.files = getSelectedTemplateFiles(templateSetResponse, aiToolResponse, templateFiles);
+    if (!options.force) {
+        const preset = resolvePreset(options.preset);
+        const installFiles = preset ? [...options.files, "STACK.md"] : options.files;
+        const targetDir = path.resolve(process.cwd(), resolvedTarget || ".");
+        const existingFiles = [];
+        for (const file of installFiles) {
+            if (await exists(path.join(targetDir, file))) {
+                existingFiles.push(file);
+            }
+        }
+        if (existingFiles.length > 0) {
+            const conflictResponse = await select({
+                message: `Existing files found: ${existingFiles.join(", ")}. How should AgentKit handle conflicts?`,
+                initialValue: "skip",
+                options: [
+                    { label: "Skip existing files", value: "skip" },
+                    { label: "Overwrite existing files", value: "overwrite" },
+                ],
+            });
+            if (isCancel(conflictResponse)) {
+                process.exit(130);
+            }
+            options.force = conflictResponse === "overwrite";
+        }
+    }
+    options.personalization = await promptForPersonalization();
+    return resolvedTarget || ".";
 }
 async function main() {
     if (process.argv.slice(2).includes("--list")) {
@@ -250,8 +647,9 @@ async function main() {
 
 Examples:
   agentkit init
+  agentkit update
   agentkit init --preset next
-  agentkit init ./my-project --dry-run
+  agentkit init ./my-project --yes --dry-run
   agentkit --list-presets
   agentkit --list`);
     program
@@ -268,10 +666,22 @@ Examples:
         const result = await installTemplates(resolvedTarget, options);
         printInstallResult(result, Boolean(options.dryRun));
     });
+    program
+        .command("update")
+        .description("update AgentKit managed template blocks in a project")
+        .argument("[target]", "target project directory", ".")
+        .option("--dry-run", "print planned changes without writing files")
+        .option("--preset <name>", `update stack-specific guidance (${formatPresetList()})`)
+        .action(async (target, options) => {
+        const result = await updateTemplates(target, options);
+        printUpdateResult(result, Boolean(options.dryRun));
+    });
     await program.parseAsync(process.argv);
 }
-main().catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(message);
-    process.exitCode = 1;
-});
+if (process.argv[1] && path.resolve(process.argv[1]) === __filename) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+    });
+}

package/package.json

@@ -1,8 +1,25 @@
 {
   "name": "thomas-agentkit",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Install AI-agent-ready development templates into a project.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/howie1329/Howard-AgentKit.git"
+  },
+  "homepage": "https://github.com/howie1329/Howard-AgentKit#readme",
+  "bugs": {
+    "url": "https://github.com/howie1329/Howard-AgentKit/issues"
+  },
+  "keywords": [
+    "agentkit",
+    "ai",
+    "agents",
+    "codex",
+    "cli",
+    "scaffolding",
+    "templates"
+  ],
   "type": "module",
   "bin": {
     "agentkit": "./dist/cli.js"