@meltstudio/meltctl 3.0.0 → 4.0.0

package/dist/commands/init.js

@@ -1,9 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_DIR = path.join(__dirname, '../../templates');
+import { authenticatedFetch, isAuthenticated } from '../utils/auth.js';
 const SKILL_FRONTMATTER = {
     plan: `---
 user-invocable: true
@@ -31,6 +29,14 @@ description: Systematically investigate and fix bugs
 `,
 };
 const GITIGNORE_ENTRIES = ['.env.local', '.claude/settings.local.json'];
+async function fetchTemplates() {
+    const response = await authenticatedFetch('/templates');
+    if (!response.ok) {
+        throw new Error(`Failed to fetch templates: ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return data.files;
+}
 export async function initCommand(options) {
     const cwd = process.cwd();
     // Check if already initialized (AGENTS.md exists)
@@ -38,34 +44,75 @@ export async function initCommand(options) {
         console.log(chalk.yellow('Project already has an AGENTS.md file. Use --force to overwrite.'));
         process.exit(1);
     }
+    // Require authentication
+    if (!(await isAuthenticated())) {
+        console.error(chalk.red('Not authenticated. Run `meltctl login` first.'));
+        process.exit(1);
+    }
+    let templates;
+    try {
+        templates = await fetchTemplates();
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('expired')) {
+            console.error(chalk.red('Session expired. Run `meltctl login` to re-authenticate.'));
+        }
+        else if (error instanceof Error && error.message.includes('fetch')) {
+            console.error(chalk.red('Could not reach Melt API. Check your connection.'));
+        }
+        else {
+            console.error(chalk.red(`Failed to fetch templates: ${error instanceof Error ? error.message : 'Unknown error'}`));
+        }
+        process.exit(1);
+    }
     console.log(chalk.bold('Initializing Melt development tools...'));
     console.log();
     // Copy AGENTS.md
-    await fs.copyFile(path.join(TEMPLATES_DIR, 'agents-md.md'), path.join(cwd, 'AGENTS.md'));
+    const agentsMd = templates['agents-md.md'];
+    if (agentsMd) {
+        await fs.writeFile(path.join(cwd, 'AGENTS.md'), agentsMd, 'utf-8');
+    }
     // Copy .claude/settings.json
-    await fs.ensureDir(path.join(cwd, '.claude'));
-    await fs.copyFile(path.join(TEMPLATES_DIR, 'claude-settings.json'), path.join(cwd, '.claude/settings.json'));
+    const claudeSettings = templates['claude-settings.json'];
+    if (claudeSettings) {
+        await fs.ensureDir(path.join(cwd, '.claude'));
+        await fs.writeFile(path.join(cwd, '.claude/settings.json'), claudeSettings, 'utf-8');
+    }
     // Create Claude skills from workflow templates
     const workflows = ['plan', 'review', 'pr', 'debug'];
     for (const name of workflows) {
-        const skillDir = path.join(cwd, `.claude/skills/melt-${name}`);
-        await fs.ensureDir(skillDir);
-        const workflowContent = await fs.readFile(path.join(TEMPLATES_DIR, `workflows/${name}.md`), 'utf-8');
-        const skillContent = SKILL_FRONTMATTER[name] + workflowContent;
-        await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf-8');
+        const workflowContent = templates[`workflows/${name}.md`];
+        if (workflowContent) {
+            const skillDir = path.join(cwd, `.claude/skills/melt-${name}`);
+            await fs.ensureDir(skillDir);
+            const skillContent = SKILL_FRONTMATTER[name] + workflowContent;
+            await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillContent, 'utf-8');
+        }
     }
     // Copy .cursor/rules/standards.mdc
-    await fs.ensureDir(path.join(cwd, '.cursor/rules'));
-    await fs.copyFile(path.join(TEMPLATES_DIR, 'cursor-rules.mdc'), path.join(cwd, '.cursor/rules/standards.mdc'));
+    const cursorRules = templates['cursor-rules.mdc'];
+    if (cursorRules) {
+        await fs.ensureDir(path.join(cwd, '.cursor/rules'));
+        await fs.writeFile(path.join(cwd, '.cursor/rules/standards.mdc'), cursorRules, 'utf-8');
+    }
     // Copy Cursor commands from workflow templates
     await fs.ensureDir(path.join(cwd, '.cursor/commands'));
     for (const name of workflows) {
-        await fs.copyFile(path.join(TEMPLATES_DIR, `workflows/${name}.md`), path.join(cwd, `.cursor/commands/melt-${name}.md`));
+        const workflowContent = templates[`workflows/${name}.md`];
+        if (workflowContent) {
+            await fs.writeFile(path.join(cwd, `.cursor/commands/melt-${name}.md`), workflowContent, 'utf-8');
+        }
     }
     // Copy .mcp.json
-    await fs.copyFile(path.join(TEMPLATES_DIR, 'mcp-configs/base.json'), path.join(cwd, '.mcp.json'));
+    const mcpConfig = templates['mcp-configs/base.json'];
+    if (mcpConfig) {
+        await fs.writeFile(path.join(cwd, '.mcp.json'), mcpConfig, 'utf-8');
+    }
     // Copy .env.melt.example
-    await fs.copyFile(path.join(TEMPLATES_DIR, 'env-melt-example'), path.join(cwd, '.env.melt.example'));
+    const envExample = templates['env-melt-example'];
+    if (envExample) {
+        await fs.writeFile(path.join(cwd, '.env.melt.example'), envExample, 'utf-8');
+    }
     // Update .gitignore
     await updateGitignore(cwd);
     // Print summary

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import http from 'http';
+import { URL } from 'url';
+import { exec } from 'child_process';
+import { API_BASE, storeAuth } from '../utils/auth.js';
+import { printBanner } from '../utils/banner.js';
+const LOGIN_TIMEOUT_MS = 60_000;
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${command} "${url}"`);
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer();
+        server.listen(0, () => {
+            const address = server.address();
+            if (address && typeof address === 'object') {
+                const port = address.port;
+                server.close(() => resolve(port));
+            }
+            else {
+                reject(new Error('Could not find free port'));
+            }
+        });
+    });
+}
+export async function loginCommand() {
+    printBanner();
+    console.log(chalk.bold('  Logging in to Melt...'));
+    const port = await findFreePort();
+    const redirectUri = `http://localhost:${port.toString()}`;
+    const authCode = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Authentication timed out. Please try again.'));
+        }, LOGIN_TIMEOUT_MS);
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://localhost:${port.toString()}`);
+            const code = url.searchParams.get('code');
+            const error = url.searchParams.get('error');
+            if (error) {
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end('<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>');
+                clearTimeout(timeout);
+                server.close();
+                reject(new Error(`Authentication denied: ${error}`));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { 'Content-Type': 'text/html' });
+                res.end('<html><body><h2>Missing authorization code</h2></body></html>');
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end('<html><body><h2>Authentication successful!</h2><p>You can close this tab and return to your terminal.</p></body></html>');
+            clearTimeout(timeout);
+            server.close();
+            resolve(code);
+        });
+        server.listen(port, () => {
+            const authUrl = `${API_BASE}/auth/google?redirect_uri=${encodeURIComponent(redirectUri)}`;
+            console.log(chalk.dim('Opening browser for authentication...'));
+            openBrowser(authUrl);
+            console.log(chalk.dim(`If the browser doesn't open, visit: ${authUrl}`));
+        });
+    });
+    console.log(chalk.dim('Exchanging authorization code...'));
+    const response = await fetch(`${API_BASE}/auth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ code: authCode, redirect_uri: redirectUri }),
+    });
+    if (!response.ok) {
+        const error = (await response.json());
+        if (response.status === 403) {
+            console.error(chalk.red('Only @meltstudio.co accounts can use this tool.'));
+            process.exit(1);
+        }
+        console.error(chalk.red(`Authentication failed: ${error.error ?? 'Unknown error'}`));
+        process.exit(1);
+    }
+    const data = (await response.json());
+    await storeAuth({
+        token: data.token,
+        email: data.email,
+        expiresAt: data.expiresAt,
+    });
+    console.log();
+    console.log(chalk.green(`Logged in as ${data.email}`));
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logoutCommand(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+import { clearAuth, getStoredAuth } from '../utils/auth.js';
+export async function logoutCommand() {
+    const auth = await getStoredAuth();
+    await clearAuth();
+    if (auth) {
+        console.log(chalk.green(`Logged out (was ${auth.email})`));
+    }
+    else {
+        console.log(chalk.dim('No active session found.'));
+    }
+}

package/dist/index.js

@@ -4,6 +4,9 @@ import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { initCommand } from './commands/init.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { printBanner } from './utils/banner.js';
 import { checkAndEnforceUpdate } from './utils/version-check.js';
 import { versionCheckCommand } from './commands/version.js';
 // Read version from package.json
@@ -13,22 +16,39 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'),
 const program = new Command();
 program
     .name('meltctl')
-    .description('AI-first development tools for teams')
+    .description('Set up AI-first development standards (AGENTS.md, Claude skills, Cursor rules, MCP config) in your project.\n\nRequires a @meltstudio.co Google Workspace account. Run `meltctl login` first, then `meltctl project init` in your repo.')
     .version(packageJson.version)
+    .addHelpText('beforeAll', () => {
+    printBanner();
+    return '';
+})
     .hook('preAction', async () => {
     await checkAndEnforceUpdate();
 });
 program
+    .command('login')
+    .description('authenticate with Google Workspace (opens browser)')
+    .action(async () => {
+    await loginCommand();
+});
+program
+    .command('logout')
+    .description('clear stored credentials from ~/.meltctl/')
+    .action(async () => {
+    await logoutCommand();
+});
+const project = program.command('project').description('manage project configuration');
+project
     .command('init')
-    .description('Initialize project with Melt development tools')
-    .option('--force', 'overwrite existing files')
+    .description('scaffold Melt development tools into the current directory (AGENTS.md, .claude/, .cursor/, .mcp.json)')
+    .option('--force', 'overwrite existing files if already initialized')
     .action(options => {
     return initCommand({ force: options.force });
 });
 program
     .command('version')
-    .description('Display version information')
-    .option('--check', 'check for updates')
+    .description('show current version')
+    .option('--check', 'also check for available updates')
     .action(async (options) => {
     if (options.check) {
         await versionCheckCommand();

package/dist/utils/auth.d.ts

@@ -0,0 +1,12 @@
+export declare const API_BASE: string;
+interface StoredAuth {
+    token: string;
+    email: string;
+    expiresAt: string;
+}
+export declare function getStoredAuth(): Promise<StoredAuth | undefined>;
+export declare function storeAuth(auth: StoredAuth): Promise<void>;
+export declare function clearAuth(): Promise<void>;
+export declare function isAuthenticated(): Promise<boolean>;
+export declare function authenticatedFetch(urlPath: string): Promise<Response>;
+export {};

package/dist/utils/auth.js

@@ -0,0 +1,52 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+const AUTH_DIR = path.join(os.homedir(), '.meltctl');
+const AUTH_FILE = path.join(AUTH_DIR, 'auth.json');
+export const API_BASE = process.env['MELTCTL_API_URL'] ??
+    'https://ewszkw32he2ebgkwlbwmoubf5y0hllpx.lambda-url.us-east-1.on.aws';
+export async function getStoredAuth() {
+    if (!(await fs.pathExists(AUTH_FILE))) {
+        return undefined;
+    }
+    try {
+        return (await fs.readJson(AUTH_FILE));
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function storeAuth(auth) {
+    await fs.ensureDir(AUTH_DIR);
+    await fs.writeJson(AUTH_FILE, auth, { spaces: 2 });
+}
+export async function clearAuth() {
+    if (await fs.pathExists(AUTH_FILE)) {
+        await fs.remove(AUTH_FILE);
+    }
+}
+export async function isAuthenticated() {
+    const auth = await getStoredAuth();
+    if (!auth) {
+        return false;
+    }
+    return new Date(auth.expiresAt) > new Date();
+}
+export async function authenticatedFetch(urlPath) {
+    const auth = await getStoredAuth();
+    if (!auth) {
+        throw new Error('Not authenticated. Run `meltctl login` first.');
+    }
+    if (new Date(auth.expiresAt) <= new Date()) {
+        throw new Error('Session expired. Run `meltctl login` to re-authenticate.');
+    }
+    const response = await fetch(`${API_BASE}${urlPath}`, {
+        headers: {
+            Authorization: `Bearer ${auth.token}`,
+        },
+    });
+    if (response.status === 401) {
+        throw new Error('Session expired. Run `meltctl login` to re-authenticate.');
+    }
+    return response;
+}

package/dist/utils/banner.d.ts

@@ -0,0 +1 @@
+export declare function printBanner(): void;

package/dist/utils/banner.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import gradient from 'gradient-string';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
+// Melt brand colors: yellow, magenta/pink, cyan, red, orange
+const meltGradient = gradient(['#FFC107', '#E91E63', '#00BCD4', '#FF5722']);
+const LOGO = `
+  ███╗   ███╗███████╗██╗  ████████╗ ██████╗████████╗██╗
+  ████╗ ████║██╔════╝██║  ╚══██╔══╝██╔════╝╚══██╔══╝██║
+  ██╔████╔██║█████╗  ██║     ██║   ██║        ██║   ██║
+  ██║╚██╔╝██║██╔══╝  ██║     ██║   ██║        ██║   ██║
+  ██║ ╚═╝ ██║███████╗███████╗██║   ╚██████╗   ██║   ███████╗
+  ╚═╝     ╚═╝╚══════╝╚══════╝╚═╝    ╚═════╝   ╚═╝   ╚══════╝`;
+export function printBanner() {
+    console.log(meltGradient(LOGO));
+    console.log();
+    console.log(`  ${chalk.dim('v' + pkg.version)}  ${chalk.dim('·')}  ${chalk.dim('AI-first development tools for teams')}`);
+    console.log();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltstudio/meltctl",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "AI-first development tools for teams - set up AGENTS.md, Claude Code, Cursor, and Copilot standards",
   "main": "dist/index.js",
   "type": "module",
@@ -9,7 +9,6 @@
   },
   "files": [
     "dist/**/*",
-    "templates/**/*",
     "README.md",
     "LICENSE"
   ],
@@ -48,10 +47,11 @@
   "author": "Melt Studio",
   "license": "MIT",
   "dependencies": {
-    "commander": "^12.1.0",
     "@commander-js/extra-typings": "^12.1.0",
     "chalk": "^5.4.1",
-    "fs-extra": "^11.2.0"
+    "commander": "^12.1.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",

package/templates/agents-md.md

@@ -1,117 +0,0 @@
-# AGENTS.md
-
-## Project Overview
-
-<!-- Describe your project here: what it does, key technologies, and architecture overview -->
-
-## Architecture Standards
-
-### Important: Respect Existing Code
-
-Before applying any standards below, **understand the existing project structure first**. If the project already follows a different architecture or pattern, continue following the existing conventions. These standards apply to new code in greenfield areas - never refactor or restructure existing code to match these guidelines unless explicitly asked.
-
-### Recommended Structure (for new projects/domains)
-
-For new frontend code, prefer domain-driven architecture:
-
-```
-src/
-  domains/
-    <domain>/
-      components/     # UI components scoped to this domain
-      hooks/          # Custom hooks for this domain
-      services/       # API calls and business logic
-      types/          # TypeScript types and interfaces
-      utils/          # Domain-specific utilities
-  shared/
-    components/       # Shared UI components
-    hooks/            # Shared custom hooks
-    services/         # Shared API services
-    types/            # Shared TypeScript types
-    utils/            # Shared utilities
-```
-
-- Each domain is self-contained with its own components, hooks, services, types, and utils
-- Cross-domain imports go through the `shared/` directory
-- Never import directly between domains
-
-If the project uses a different structure, follow the existing patterns instead.
-
-### TypeScript Standards
-- Strict mode enabled (`strict: true` in tsconfig)
-- No `any` types - use `unknown` with type guards when the type is truly unknown
-- Validate external data with Zod schemas at system boundaries
-- Export types from dedicated `types.ts` files
-
-### Code Quality
-- Minimum 80% test coverage for new code
-- Use conventional commits (feat:, fix:, chore:, docs:, refactor:, test:)
-- No eslint-disable comments without team approval
-- All functions must have explicit return types
-- Prefer composition over inheritance
-
-## Agent Permissions
-
-### Automatically Approved (No Confirmation Needed)
-- Reading any file in the repository
-- Running tests, linters, type checkers, and formatters
-- Git read operations (status, log, diff, branch)
-- Searching code and exploring the codebase
-- Package dependency lookups
-
-### Requires Approval
-- Writing or modifying files
-- Git write operations (add, commit, checkout, branch creation)
-- Running build commands
-- Installing or removing dependencies
-- Creating pull requests or issues
-
-### Blocked (Never Execute)
-- `git push --force` or `git push --force-with-lease`
-- `git reset --hard`
-- `rm -rf /` or any recursive delete of root paths
-- Force push to main or master branches
-- Dropping database tables in production
-- Modifying CI/CD pipeline files without explicit request
-
-## Tool Access
-
-### CLI Tools
-- Use `gh` CLI for GitHub operations (PRs, issues, releases)
-- Use project's package manager (check for yarn.lock, pnpm-lock.yaml, or package-lock.json)
-- Run tests with the project's configured test runner
-
-### Browser (via DevTools MCP)
-- Use Chrome DevTools MCP server for browser testing when available
-- Inspect elements, check console errors, verify visual output
-- Test responsive layouts and interactions
-
-### Databases
-- Read queries are safe to execute
-- Write queries require approval
-- Schema changes require explicit request and approval
-
-## Project Management
-
-- Reference issue/ticket IDs in commit messages and PR descriptions
-- Follow the team's workflow for issue progression
-- Update ticket status when starting and completing work
-
-## Workflow Skills
-
-The following workflows are available as AI skills:
-
-- **plan** - Gather requirements, explore codebase, design approach, present plan for approval
-- **review** - Review changes against these standards, categorize findings
-- **pr** - Analyze changes, draft PR description, run pre-flight checks, create PR
-- **debug** - Investigate issues, isolate root cause, write regression test, fix
-
-## Customization
-
-<!-- Add project-specific standards below this line -->
-<!-- Examples of things to add: -->
-<!-- - API conventions (REST patterns, error formats, pagination) -->
-<!-- - Component patterns (naming, file structure, state management) -->
-<!-- - Database rules (naming conventions, migration patterns) -->
-<!-- - Testing patterns (what to mock, integration test setup) -->
-<!-- - Deployment rules (environment-specific concerns) -->

package/templates/claude-settings.json

@@ -1,36 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git status*)",
-      "Bash(git log*)",
-      "Bash(git diff*)",
-      "Bash(git branch*)",
-      "Bash(git show*)",
-      "Bash(npm test*)",
-      "Bash(yarn test*)",
-      "Bash(pnpm test*)",
-      "Bash(npx vitest*)",
-      "Bash(npx jest*)",
-      "Bash(npm run lint*)",
-      "Bash(yarn lint*)",
-      "Bash(pnpm lint*)",
-      "Bash(npm run build*)",
-      "Bash(yarn build*)",
-      "Bash(pnpm build*)",
-      "Bash(npx tsc*)",
-      "Bash(gh pr *)",
-      "Bash(gh issue *)",
-      "Read(*)"
-    ],
-    "deny": [
-      "Bash(git push --force*)",
-      "Bash(git push * --force*)",
-      "Bash(git push --force-with-lease*)",
-      "Bash(git push * --force-with-lease*)",
-      "Bash(git reset --hard*)",
-      "Bash(rm -rf /*)",
-      "Bash(git push * main*)",
-      "Bash(git push * master*)"
-    ]
-  }
-}

package/templates/cursor-rules.mdc

@@ -1,39 +0,0 @@
----
-description: Melt development standards and architecture guidelines
-globs:
-alwaysApply: true
----
-
-# Project Standards
-
-## Important
-- Always understand the existing project structure before making changes
-- If the project follows different conventions than listed here, follow the existing patterns
-- These standards apply to new greenfield code - never refactor existing code to match unless asked
-
-## Architecture
-- Prefer domain-driven architecture for new code: `src/domains/<domain>/{components,hooks,services,types,utils}`
-- Cross-domain imports go through `src/shared/`
-- Never import directly between domains
-- Follow existing project patterns when they differ from the above
-
-## TypeScript
-- Strict mode enabled, no `any` types
-- Validate external data with Zod at system boundaries
-- All functions must have explicit return types
-
-## Code Quality
-- 80% minimum test coverage for new code
-- Conventional commits (feat:, fix:, chore:, docs:, refactor:, test:)
-- No eslint-disable comments without team approval
-
-## Agent Behavior
-- Read operations: auto-approved
-- Write operations: require developer approval
-- Destructive operations: blocked (no force push, no hard reset)
-
-## Workflows
-- Use `plan` before starting non-trivial implementations
-- Use `review` to check changes against these standards
-- Use `pr` to create well-structured pull requests
-- Use `debug` for systematic bug investigation

package/templates/env-melt-example

@@ -1,23 +0,0 @@
-# Melt Development Tools - Environment Variables
-# Copy this file to .env.local and fill in your values
-# Never commit .env.local to version control
-
-# --- Linear (if using Linear for project management) ---
-# LINEAR_API_KEY=lin_api_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-
-# --- Jira (if using Jira for project management) ---
-# JIRA_API_TOKEN=your-jira-api-token
-# JIRA_BASE_URL=https://your-org.atlassian.net
-# JIRA_USER_EMAIL=your-email@company.com
-
-# --- Database (if agents need database access) ---
-# DATABASE_URL=postgresql://user:password@localhost:5432/dbname
-
-# --- AWS (if agents need AWS access) ---
-# AWS_ACCESS_KEY_ID=your-access-key
-# AWS_SECRET_ACCESS_KEY=your-secret-key
-# AWS_REGION=us-east-1
-
-# --- Other Integrations ---
-# OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-# ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

package/templates/mcp-configs/base.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "chrome-devtools": {
-      "command": "npx",
-      "args": ["-y", "@anthropic-ai/chrome-devtools-mcp@latest"]
-    }
-  }
-}

package/templates/workflows/debug.md

@@ -1,32 +0,0 @@
-# Debug
-
-Investigate and fix bugs systematically.
-
-## Instructions
-
-1. **Understand the Problem**
-   - Read the bug report or error description
-   - Reproduce the issue if possible
-   - Identify expected vs actual behavior
-
-2. **Investigate**
-   - Search the codebase for relevant code paths
-   - Read error messages and stack traces carefully
-   - Use browser DevTools MCP if it's a UI issue
-   - Check recent changes that might have introduced the bug
-   - Add temporary logging if needed to trace execution
-
-3. **Isolate the Root Cause**
-   - Narrow down to the specific file and function
-   - Understand why the current code produces the wrong behavior
-   - Verify your hypothesis by checking related code paths
-
-4. **Write a Regression Test**
-   - Write a test that reproduces the bug (it should fail before the fix)
-   - Cover the specific edge case that caused the issue
-
-5. **Fix the Bug**
-   - Make the minimal change needed to fix the issue
-   - Verify the regression test now passes
-   - Run the full test suite to check for regressions
-   - Clean up any temporary debugging code

package/templates/workflows/plan.md

@@ -1,32 +0,0 @@
-# Plan
-
-Design an implementation approach before writing code.
-
-## Instructions
-
-1. **Gather Requirements**
-   - Read the task description carefully
-   - Identify acceptance criteria and constraints
-   - Ask clarifying questions if requirements are ambiguous
-
-2. **Explore the Codebase**
-   - Find relevant files and understand existing patterns
-   - Check for similar implementations to follow as examples
-   - Identify files that will need changes
-
-3. **Design the Approach**
-   - Break the task into concrete implementation steps
-   - Consider edge cases and error handling
-   - Note any dependencies or ordering constraints
-   - Estimate which files will be created or modified
-
-4. **Present the Plan**
-   - Summarize the approach in a clear, numbered list
-   - Highlight any architectural decisions or trade-offs
-   - List files to be modified with a brief description of changes
-   - Call out any risks or open questions
-
-5. **Wait for Approval**
-   - Do not start implementation until the developer approves
-   - Adjust the plan based on feedback
-   - Once approved, proceed with implementation

package/templates/workflows/pr.md

@@ -1,28 +0,0 @@
-# Pull Request
-
-Create a well-structured pull request from the current changes.
-
-## Instructions
-
-1. **Analyze Changes**
-   - Run `git diff` to understand all changes
-   - Run `git log` to review commit history on this branch
-   - Identify the purpose and scope of the changes
-
-2. **Draft PR Description**
-   - Write a clear title (under 70 characters)
-   - Summarize changes in 1-3 bullet points
-   - Reference related issues or tickets
-   - Note any breaking changes or migration steps
-
-3. **Run Pre-flight Checks**
-   - Run the test suite and verify all tests pass
-   - Run the linter and fix any issues
-   - Run type checking and resolve any errors
-   - Verify the build succeeds
-
-4. **Create the PR**
-   - Use `gh pr create` with the drafted title and description
-   - Add appropriate labels if the project uses them
-   - Request reviewers if specified
-   - Return the PR URL to the developer

package/templates/workflows/review.md

@@ -1,28 +0,0 @@
-# Review
-
-Review code changes against project standards.
-
-## Instructions
-
-1. **Understand Context**
-   - Read the PR description or task context
-   - Understand what the changes are trying to accomplish
-   - Check AGENTS.md for project-specific standards
-
-2. **Review the Changes**
-   - Read all modified files carefully
-   - Check for correctness, readability, and maintainability
-   - Verify adherence to architecture standards (domain structure, typing, etc.)
-   - Look for potential bugs, edge cases, or security issues
-   - Check that tests cover the changes adequately
-
-3. **Categorize Findings**
-   - **Must Fix**: Bugs, security issues, broken functionality, standards violations
-   - **Should Fix**: Code quality issues, missing tests, unclear naming
-   - **Suggestion**: Style preferences, optional improvements, alternative approaches
-
-4. **Present the Review**
-   - Start with a summary of what the changes do
-   - List findings by category with file paths and line numbers
-   - Provide specific suggestions for how to fix each issue
-   - End with an overall assessment (approve, request changes, or needs discussion)