@zweer/dev 1.3.0 → 2.0.0

package/kiro/skills/agent-template/references/example-monorepo-library.json

@@ -0,0 +1,60 @@
+{
+  "name": "dev",
+  "description": "Agent for __NAME__ - TypeScript library with npm packages",
+  "prompt": "file://../prompts/dev.md",
+  "resources": [
+    "file://README.md",
+    "file://.kiro/specs/**/*.md",
+    "file://.kiro/steering/**/*.md",
+    "file://docs/**/*.md"
+  ],
+  "tools": [
+    "read",
+    "write",
+    "shell",
+    "grep",
+    "glob",
+    "web_search",
+    "web_fetch",
+    "introspect",
+    "thinking",
+    "code"
+  ],
+  "allowedTools": [
+    "read",
+    "shell",
+    "grep",
+    "glob",
+    "web_search",
+    "web_fetch",
+    "introspect",
+    "thinking",
+    "code"
+  ],
+  "toolsSettings": {
+    "write": {
+      "allowedPaths": [
+        ".kiro/**",
+        "packages/**",
+        "docs/**",
+        "scripts/**",
+        ".github/**",
+        "README.md",
+        "CHANGELOG.md",
+        "package.json",
+        "package-lock.json",
+        "tsconfig.json",
+        "tsdown.config.ts",
+        "vitest.config.ts",
+        "biome.json",
+        ".editorconfig",
+        ".gitignore",
+        ".npmpackagejsonlintrc.json"
+      ]
+    },
+    "shell": {
+      "autoAllowReadonly": true,
+      "deniedCommands": [".*git commit.*", ".*git push.*", ".*git tag .*", ".*npm publish.*"]
+    }
+  }
+}

package/kiro/skills/agent-template/references/example-webapp-vercel.json

@@ -0,0 +1,54 @@
+{
+  "name": "dev",
+  "description": "Agent for __NAME__ - Web application deployed on Vercel",
+  "prompt": "file://../prompts/dev.md",
+  "resources": ["file://README.md", "file://.kiro/specs/**/*.md", "file://.kiro/steering/**/*.md"],
+  "tools": [
+    "read",
+    "write",
+    "shell",
+    "grep",
+    "glob",
+    "web_search",
+    "web_fetch",
+    "introspect",
+    "thinking",
+    "code"
+  ],
+  "allowedTools": [
+    "read",
+    "shell",
+    "grep",
+    "glob",
+    "web_search",
+    "web_fetch",
+    "introspect",
+    "thinking",
+    "code"
+  ],
+  "toolsSettings": {
+    "write": {
+      "allowedPaths": [
+        ".kiro/**",
+        ".github/**",
+        "packages/**",
+        "docs/**",
+        "README.md",
+        "CHANGELOG.md",
+        "package.json",
+        "package-lock.json",
+        "tsconfig.json",
+        "vitest.config.ts",
+        "biome.json",
+        ".editorconfig",
+        ".gitignore",
+        "docker-compose.yml",
+        "Dockerfile"
+      ]
+    },
+    "shell": {
+      "autoAllowReadonly": true,
+      "deniedCommands": [".*git commit.*", ".*git push.*", ".*git tag .*", ".*npm publish.*"]
+    }
+  }
+}

package/kiro/skills/prompt-template/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: prompt-template
+description: Generate .kiro/prompts/dev.md for a project. Use when creating the agent's system prompt.
+---
+
+# Prompt Template
+
+Generate a `.kiro/prompts/dev.md` file tailored to the project.
+
+## Structure
+
+Every prompt should have these sections:
+1. **Title & Role** — "You are the __NAME__ Development Agent"
+2. **Project Mission** — What the project does, in 2-3 sentences
+3. **Project Knowledge** — Which specs/docs to always reference
+4. **Architecture Overview** — Tech stack, structure, design principles
+5. **Development Guidelines** — TypeScript style, testing, code quality
+6. **Git Rules** — NEVER commit/push, suggest commit messages
+7. **Communication Style** — Language, tone, focus
+
+## References
+- Review `references/example-library.md` for npm library prompts
+- Review `references/example-webapp.md` for web app prompts

package/kiro/skills/prompt-template/references/example-library.md

@@ -0,0 +1,56 @@
+# __NAME__ Development Agent
+
+You are the **__NAME__ Development Agent**. You help develop and maintain __NAME__ — a TypeScript library published to npm.
+
+## Project Mission
+
+Build a **modular TypeScript library** that:
+- Works as an npm package (not a server)
+- Has clean, well-tested APIs
+- Is published to npm with proper types and sourcemaps
+
+## Project Knowledge
+
+**ALWAYS refer to these files for context**:
+- `.kiro/specs/` — Project requirements and design decisions
+- `README.md` — Project overview and documentation
+
+## Architecture Overview
+
+### Monorepo Structure
+```
+__NAME__/
+├── packages/
+│   ├── core/              # Core library
+│   └── ...                # Additional packages
+├── docs/                  # VitePress documentation
+└── README.md
+```
+
+### Tech Stack
+- **Language**: TypeScript (strict mode)
+- **Build**: tsdown
+- **Test**: Vitest
+- **Lint**: Biome
+- **Release**: bonvoy
+
+## Development Guidelines
+
+### TypeScript
+- Strict mode, no `any`, explicit types
+- ES modules with `.js` extensions in imports
+- camelCase for code, kebab-case for files
+
+### Testing
+- Vitest for all tests, high coverage target
+- Mock external services, test real implementations
+
+## Git Rules
+
+**NEVER commit, push, or create tags.** Prepare changes and suggest a commit message.
+
+## Communication Style
+
+- **Language**: English for all code and docs
+- **Tone**: Direct and concise
+- **Focus**: Practical solutions, simplicity, testability

package/kiro/skills/prompt-template/references/example-webapp.md

@@ -0,0 +1,57 @@
+# __NAME__ Development Agent
+
+You are the **__NAME__ Development Agent**. You help develop and maintain __NAME__ — a web application deployed on Vercel.
+
+## Project Mission
+
+Build a **modern web application** that:
+- Provides an excellent user experience
+- Is deployed on Vercel (serverless, zero infrastructure)
+- Has a clean, maintainable codebase
+
+## Project Knowledge
+
+**ALWAYS refer to these files for context**:
+- `.kiro/specs/` — Project requirements and design decisions
+- `README.md` — Project overview
+
+## Architecture Overview
+
+### Project Structure
+```
+__NAME__/
+├── packages/
+│   ├── api/               # Backend API
+│   ├── web/               # Frontend
+│   └── shared/            # Shared types/utils
+└── README.md
+```
+
+### Tech Stack
+- **Frontend**: SvelteKit / Next.js
+- **Backend**: Hono / API routes
+- **Database**: PostgreSQL (Neon) + Drizzle ORM
+- **Deploy**: Vercel
+- **Build**: Vite (frontend), tsdown (shared)
+- **Test**: Vitest
+
+## Development Guidelines
+
+### TypeScript
+- Strict mode, no `any`, explicit types
+- ES modules with `.js` extensions
+- camelCase for code, kebab-case for files
+
+### Testing
+- Vitest for all tests
+- Mock database and external services
+
+## Git Rules
+
+**NEVER commit, push, or create tags.** Prepare changes and suggest a commit message.
+
+## Communication Style
+
+- **Language**: English for all code and docs
+- **Tone**: Direct and concise
+- **Focus**: User experience, clean code, practical solutions

package/kiro/skills/skill-templates/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: skill-templates
+description: Generate .kiro/skills/ for a project. Use when adding skills like new-package scaffolding to a monorepo.
+---
+
+# Skill Templates
+
+Generate project-specific skills under `.kiro/skills/`.
+
+## Available Skills
+
+### new-package (monorepos only)
+Scaffolds a new package in a monorepo. Includes:
+- Directory structure, package.json, src/index.ts, test file
+- README.md, CHANGELOG.md
+- Updates .vscode/settings.json scopes
+
+## When to Include
+
+- `new-package` — Only for monorepo projects with `workspaces` in package.json
+
+## References
+- Review `references/new-package.md` for the new-package skill content

package/kiro/skills/skill-templates/references/new-package.md

@@ -0,0 +1,72 @@
+# Create New Package in Monorepo
+
+## 1. Detect project structure
+
+Check if the project uses:
+- npm workspaces (`package.json` has `"workspaces"` field)
+- Workspace pattern (e.g., `packages/*`)
+- Naming convention (scoped like `@org/name` or unscoped)
+
+## 2. Read existing package metadata
+
+From root `package.json` or an existing package, extract:
+- `author`, `license`, `repository`, `homepage`, `bugs`
+
+## 3. Create directory structure
+
+```bash
+mkdir -p <workspace-path>/<name>/{src,test}
+```
+
+## 4. Create package.json
+
+```json
+{
+  "name": "<package-name>",
+  "version": "0.0.0",
+  "description": "<Short description>",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": ["dist"],
+  "dependencies": {},
+  "engines": { "node": ">=<version from root>" }
+}
+```
+
+Use `^` for internal deps (e.g., `"@org/core": "^1.0.0"`).
+
+## 5. Create src/index.ts
+
+Minimal entry point with a placeholder export.
+
+## 6. Create test file
+
+Match the project's test framework (Vitest):
+
+```typescript
+import { describe, it, expect } from 'vitest';
+import { hello } from '../src/index.js';
+
+describe('Package', () => {
+  it('should work', () => {
+    expect(hello()).toBe('Hello from new package');
+  });
+});
+```
+
+## 7. Create README.md and CHANGELOG.md
+
+## 8. Add scope to .vscode/settings.json
+
+If `conventionalCommits.scopes` exists, add the package name (without scope prefix).
+
+## 9. Install, build, test
+
+```bash
+npm install && npm run build && npm test
+```
+
+**Note**: tsconfig.json is NOT needed per package — TypeScript uses the root tsconfig.json.

package/kiro/skills/steering-templates/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: steering-templates
+description: Generate .kiro/steering/ files for a project. Use when setting up steering docs for code style, tooling, testing, interaction, and commit conventions.
+---
+
+# Steering Templates
+
+Generate the 5 standard steering files under `.kiro/steering/`.
+
+## Files
+
+All projects get these 5 files:
+1. `code-style.md` — TypeScript conventions, naming, error handling
+2. `build-tooling.md` — Stack reference (tsdown, biome, lefthook, npm)
+3. `testing.md` — Vitest, coverage, mocking rules
+4. `interaction.md` — Agent behavior (interview, plan mode, no git commit)
+5. `commit-conventions.md` — Conventional commits + gitmoji text codes
+
+## Customization
+
+Adapt each file to the project:
+- `build-tooling.md` — Add project-specific scripts, build commands, deploy info
+- `testing.md` — Add project-specific test patterns (e.g., PGlite for DB tests)
+- `code-style.md` — Add project-specific conventions (e.g., Svelte component style)
+
+## References
+- Review `references/code-style.md` for the code style template
+- Review `references/build-tooling.md` for the build tooling template
+- Review `references/testing.md` for the testing template
+- Review `references/interaction.md` for the interaction template
+- Review `references/commit-conventions.md` for the commit conventions template

package/kiro/skills/steering-templates/references/build-tooling.md

@@ -0,0 +1,62 @@
+# Build & Tooling
+
+## Build System
+
+### tsdown
+- **tsdown** for building all packages (NOT tsc, esbuild, rollup)
+- Configuration: `tsdown.config.ts` at root
+- Workspace mode for monorepos
+- Outputs: `.mjs` + `.d.ts` + sourcemaps
+- tsc is only used for type-checking (`tsc --noEmit`)
+
+### Build Commands
+```bash
+npm run build              # Build with tsdown
+npm run clean              # Remove dist/
+npm run lint:typecheck     # Type-check only (tsc --noEmit)
+```
+
+## Linting & Formatting
+
+### Biome
+- **Biome** for linting and formatting (NOT ESLint/Prettier)
+- Single quotes, 100 line width
+- Uses `.editorconfig` for indent settings
+- Import sorting with grouped blank lines
+
+### Commands
+```bash
+npm run lint               # All linters in parallel
+npm run lint:format        # Biome check + fix
+npm run lint:typecheck     # TypeScript check
+npm run lint:lockfile      # Lockfile security
+npm run lint:package       # package.json validation
+npm run lint:sort_package  # Sort package.json keys
+npm run lint:engines       # Validate engine compatibility
+```
+
+## Git Hooks
+
+### Lefthook
+- **Lefthook** for git hooks (NOT husky + lint-staged)
+- Configuration: `lefthook.yml` at root
+- Pre-commit: biome → lockfile → package-lint → sort → build → typecheck → test
+- Commit-msg: commitlint validation
+- Built-in staging support (`stage_fixed: true`)
+
+## Package Manager
+
+### npm
+- Use **npm** (NOT pnpm or yarn)
+- Lock file: `package-lock.json`
+- Workspaces enabled in root `package.json` for monorepos
+
+## Scripts Reference
+
+| Script | Description |
+|--------|-------------|
+| `npm run build` | Build with tsdown |
+| `npm run clean` | Remove dist/ |
+| `npm run lint` | All linters in parallel |
+| `npm test` | Run tests |
+| `npm run test:coverage` | Tests with coverage |

package/kiro/skills/steering-templates/references/code-style.md

@@ -0,0 +1,83 @@
+# Code Style & Best Practices
+
+## TypeScript
+
+### Strict Mode
+- Always use strict mode (enabled in `tsconfig.json`)
+- No `any` types — use `unknown` or proper types
+- Explicit return types on all exported functions
+- Explicit parameter types always
+
+### Module System
+- ES modules only (`"type": "module"` in package.json)
+- Use `.js` extensions in imports (TypeScript requirement for ES modules)
+- Example: `import { foo } from './bar.js'` (not `./bar` or `./bar.ts`)
+
+### Naming Conventions
+- **camelCase** for variables, functions, methods
+- **PascalCase** for classes, interfaces, types
+- **UPPER_SNAKE_CASE** for constants
+- **kebab-case** for file names
+
+### Code Organization
+```typescript
+// 1. Imports (external first, then internal)
+import { execa } from 'execa';
+import type { Config } from './types.js';
+
+// 2. Types/Interfaces
+export interface MyConfig {
+  option: string;
+}
+
+// 3. Constants
+const DEFAULT_TIMEOUT = 5000;
+
+// 4. Classes/Functions
+export class MyClass {}
+```
+
+### Type Definitions
+- Prefer `interface` over `type` for object shapes
+- Use `type` for unions, intersections, mapped types
+- Export all public types
+- Use `readonly` for immutable properties
+
+## Code Quality
+
+### Minimal Code
+- Write only what's necessary
+- No premature abstractions
+- No unused code or imports
+- No commented-out code in commits
+
+### Error Handling
+- Always throw typed errors with clear messages
+- Include context in error messages
+- Use `try/catch` for async operations
+
+### Async/Await
+- Prefer `async/await` over `.then()/.catch()`
+- Always handle errors in async functions
+- Use `Promise.all()` for parallel operations
+
+## Dependencies
+
+### Minimal Dependencies
+- Only add dependencies when absolutely necessary
+- Prefer native Node.js APIs when possible
+- Use `^` for dependencies (allow minor/patch updates)
+- Keep dependencies up to date — run `npm outdated` regularly
+- Security updates must be applied immediately
+
+## Comments & Documentation
+
+### When to Comment
+- Complex algorithms or non-obvious logic
+- Public APIs (JSDoc)
+- Workarounds or hacks (with explanation)
+
+### When NOT to Comment
+- Obvious code
+- Redundant information
+- Commented-out code (delete it)

package/kiro/skills/steering-templates/references/commit-conventions.md

@@ -0,0 +1,58 @@
+# Commit Conventions
+
+**IMPORTANT**: The agent NEVER commits, pushes, or creates tags. The developer handles all git operations manually.
+
+## Format
+
+Use conventional commits with gitmoji as text (not emoji):
+
+```
+type(scope): :emoji_code: short description
+
+Detailed explanation of what changed and why.
+Include multiple lines if needed to fully describe:
+- What was changed
+- Why it was changed
+- Any breaking changes or important notes
+```
+
+## Types
+
+- `feat` — New feature (`:sparkles:`)
+- `fix` — Bug fix (`:bug:`)
+- `perf` — Performance improvement (`:zap:`)
+- `docs` — Documentation (`:memo:`)
+- `chore` — Maintenance tasks (`:wrench:`, `:arrow_up:`, `:bookmark:`)
+- `refactor` — Code refactoring (`:recycle:`)
+- `test` — Tests (`:white_check_mark:`)
+- `style` — Code formatting (`:art:`)
+- `ci` — CI/CD changes (`:construction_worker:`)
+- `build` — Build system (`:hammer:`)
+
+## Scope
+
+Use only ONE scope per commit — typically the package, module, or component affected.
+
+If `.vscode/settings.json` exists with `conventionalCommits.scopes`, use those values.
+Scope is optional for cross-cutting changes.
+
+## Gitmoji
+
+**Always use text codes** (`:sparkles:`), **never actual emoji** (✨).
+
+## Body
+
+**Always include a detailed body** explaining:
+1. What was changed
+2. Why it was changed
+3. Any important context or side effects
+
+## Breaking Changes
+
+Add `!` after the type/scope and include `BREAKING CHANGE:` in the body:
+
+```
+feat(api)!: :boom: remove deprecated methods
+
+BREAKING CHANGE: Removed old API methods deprecated in v0.5.
+```

package/kiro/skills/steering-templates/references/interaction.md

@@ -0,0 +1,41 @@
+# Interaction Patterns
+
+## Interview Before Implementing
+
+For ambiguous or complex requests, ask clarifying questions BEFORE writing code:
+- What's the expected behavior?
+- Are there edge cases to consider?
+- Does this affect existing features?
+- What's the priority (quick fix vs proper solution)?
+
+Skip the interview for clear, well-defined tasks.
+
+## Plan Mode
+
+For multi-step tasks (new features, refactors, architecture changes):
+1. Write a short numbered plan first
+2. Wait for approval before implementing
+3. Adapt the plan if requirements change mid-execution
+
+Skip planning for single-file fixes, small bug fixes, or simple questions.
+
+## ASCII Diagrams
+
+Use ASCII diagrams when discussing:
+- Architecture decisions
+- Data flow between components
+- New feature design involving multiple files
+- Database schema relationships
+
+## Context Hygiene
+
+- Keep each steering/spec file under ~200 lines
+- Split files when they grow beyond that
+- One concern per file (don't mix code style with testing rules)
+- Update specs when features are completed or changed
+
+## Git Rules
+
+- **NEVER commit, push, or create tags** — the developer handles all git operations
+- Prepare changes and suggest a commit message
+- The developer reviews and commits manually

package/kiro/skills/steering-templates/references/testing.md

@@ -0,0 +1,61 @@
+# Testing Strategy
+
+## Test Framework
+
+### Vitest
+- All tests use **Vitest** (NOT Jest, Mocha, or others)
+- Configuration in `vitest.config.ts` at root
+- v8 coverage provider
+- Coverage reporters: text, json, json-summary
+
+## Test Structure
+
+### File Organization
+```
+src/
+└── feature.ts
+test/
+└── feature.test.ts
+```
+
+### Test Pattern (AAA)
+```typescript
+import { describe, it, expect } from 'vitest';
+
+describe('FeatureName', () => {
+  it('should do something specific', () => {
+    // Arrange
+    const input = 'test';
+
+    // Act
+    const result = doSomething(input);
+
+    // Assert
+    expect(result).toBe('expected');
+  });
+});
+```
+
+## Mocking
+
+### When to Mock
+- External APIs, file system, git commands, network requests
+
+### When NOT to Mock
+- Internal functions, simple utilities, pure functions
+
+## Best Practices
+
+### Test Naming
+- Use `should` in test names: "should throw error when input is invalid"
+
+### Independence
+- Each test must be independent — no shared state
+- Use `beforeEach` for setup
+
+### Edge Cases
+- Empty arrays/strings, null/undefined, invalid input, boundary values
+
+### Coverage
+- Exclude barrel re-exports (`index.ts`) and type files (`types.ts`)
+- Include all source files in coverage