ai-ops-cli 0.1.23 → 0.2.0

package/data/skills/reference-skills/db-prisma-postgresql/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: db-prisma-postgresql
+description: Use when modifying Prisma schemas, transactions, raw queries, indexes, or PostgreSQL migration safety.
+---
+
+# Prisma PostgreSQL
+
+Use this skill before changing Prisma schema, raw SQL usage, migration flow, or PostgreSQL transaction settings.
+
+Read `references/reference.md` and use it as the detailed persistence guidance.

package/data/skills/reference-skills/db-prisma-postgresql/references/reference.md

@@ -0,0 +1,25 @@
+# Prisma PostgreSQL
+
+## Constraints
+
+- Do not interpolate strings in unsafe raw SQL APIs.
+- Do not return Prisma models directly from API boundaries.
+- Do not define mutable models without `updatedAt`.
+- Do not use `$use()` middleware in Prisma v7+ patterns.
+- Do not use `prisma db push` in production.
+
+## Guidelines
+
+- Use the Prisma client generator/output layout that matches the current repo convention.
+- Use explicit pool and timeout settings.
+- Add indexes for common where/orderBy/join patterns.
+- Set explicit timeout and `maxWait` for interactive transactions.
+- Centralize datasource and migration settings.
+- Implement soft delete consistently.
+- Prefer cursor pagination over deep skip/take on large tables.
+- Use external pooling or explicit connection limits for serverless/container workloads.
+
+## Decision Rules
+
+- When Prisma API cannot express PostgreSQL behavior cleanly, use parameterized raw SQL with typed result mapping.
+- When a transaction has dependent steps, use interactive transactions with explicit timeout and wait settings.

package/data/skills/reference-skills/db-sqlalchemy-postgresql/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: db-sqlalchemy-postgresql
+description: Use when working on SQLAlchemy models, sessions, loading strategy, Alembic migrations, or PostgreSQL persistence rules.
+---
+
+# SQLAlchemy PostgreSQL
+
+Use this skill before changing SQLAlchemy models, sessions, raw SQL usage, or Alembic-managed schema changes.
+
+Read `references/reference.md` and apply it as the detailed persistence reference.

package/data/skills/reference-skills/db-sqlalchemy-postgresql/references/reference.md

@@ -0,0 +1,25 @@
+# SQLAlchemy PostgreSQL
+
+## Constraints
+
+- Do not use legacy `session.query()` patterns.
+- Do not execute raw SQL strings directly outside migrations.
+- Do not call `session.commit()` from scattered layers.
+- Do not omit `created_at` and `updated_at` on mutable models.
+- Do not change schema without Alembic migrations.
+
+## Guidelines
+
+- Use `Mapped[T]` and `mapped_column()` declarative mappings.
+- Define relationships explicitly with `back_populates`.
+- Use `AsyncSession` and `async_sessionmaker` for async stacks.
+- Implement soft delete consistently.
+- Prefer migration-safe string enums.
+- Declare indexes and unique constraints explicitly.
+- Prevent N+1 with explicit loading strategy. Do not rely on lazy loading by default.
+
+## Decision Rules
+
+- When routine CRUD is needed, prefer ORM expressions.
+- When complex analytical SQL is needed, use parameterized `text()` or a fit-for-purpose analytical engine.
+- When schema changes are required, generate and review Alembic migrations before applying them.

package/data/skills/reference-skills/frontend-app-flutter-runtime/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: frontend-app-flutter-runtime
+description: Use when implementing Flutter app features, Riverpod state, routing, immutable models, Dio networking, or shared app frontend conventions.
+---
+
+# Frontend App Flutter Runtime
+
+Use this skill for Flutter app frontend work.
+
+Read `references/reference.md` before changing widgets, Riverpod state, routing, networking, or generated model conventions.

package/data/skills/reference-skills/frontend-app-flutter-runtime/references/reference.md

@@ -0,0 +1,50 @@
+# Frontend App Flutter Runtime
+
+## Flutter Constraints
+
+- Do not use dynamic as a default type.
+- Do not put business logic in `Widget build()`.
+- Do not use StatefulWidget for shared or long-lived state.
+- Do not use GlobalKey to reach into child state for app data flow.
+- Do not keep mutable model fields.
+- Do not run heavy synchronous work on the UI thread.
+
+## Flutter Guidelines
+
+- Use Riverpod with code generation and feature-local providers.
+- Use feature-first directories and keep shared code in `lib/core`.
+- Use sealed classes and pattern matching for result and async state handling.
+- Prefer const constructors where possible.
+- Use go_router for declarative routes and deep links.
+- Use freezed for immutable models and generated equality and JSON methods.
+- Write widget tests with `ProviderScope.overrides`.
+- Profile with DevTools before optimizing.
+- Handle async states explicitly.
+- Access external APIs and storage through repositories.
+
+## App Frontend Library Constraints
+
+- Do not use the `http` package for API calls.
+- Do not use Provider or Bloc.
+- Do not handwrite data classes.
+- Do not use Navigator 1.0 push/pop APIs for routing.
+- Do not manually implement JSON serialization.
+
+## App Frontend Library Guidelines
+
+- Use `@riverpod` with riverpod_generator and build_runner.
+- Use freezed for immutable models and unions.
+- Define routes in a central GoRouter config.
+- Create one shared Dio instance via Riverpod DI.
+- Use shared_preferences or flutter_secure_storage by data sensitivity.
+- Use cached_network_image for network image caching.
+- Use very_good_analysis and treat warnings as CI failures.
+- Use intl or easy_localization with ARB-based translations.
+
+## Decision Rules
+
+- When state is local and ephemeral, keep it local.
+- When state is shared or long-lived, use Riverpod Notifier or AsyncNotifier.
+- When HTTP API calls are needed, use one DI-injected Dio client.
+- When network images are rendered, use cached_network_image.
+- When code generation is required, run build_runner instead of editing generated code.

package/data/skills/reference-skills/frontend-web-react-next-runtime/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: frontend-web-react-next-runtime
+description: Use when implementing React or Next.js frontend features, App Router structure, client state, fetch patterns, forms, or shared web frontend conventions.
+---
+
+# Frontend Web React Next Runtime
+
+Use this skill for React and Next.js web frontend work.
+
+Read `references/reference.md` before changing component boundaries, App Router behavior, state handling, fetch strategy, or shared web frontend libraries.

package/data/skills/reference-skills/frontend-web-react-next-runtime/references/reference.md

@@ -0,0 +1,51 @@
+# Frontend Web React Next Runtime
+
+## React TypeScript Constraints
+
+- Do not use `React.FC` or `FC`.
+
+## React TypeScript Guidelines
+
+- Use readonly object and array props.
+
+## Next.js Constraints
+
+- Do not import server-only code into client components.
+- Do not expose secrets through `NEXT_PUBLIC_` variables.
+- Do not use `next/router` in App Router projects.
+
+## Next.js Guidelines
+
+- Follow App Router file conventions.
+- Keep server actions in dedicated files.
+- Use `next/image` with explicit sizing.
+- Use `next/font` in the root layout.
+- Use `middleware.ts` only for cross-cutting concerns.
+- Export metadata for public pages.
+- Add JSON-LD when SEO or GEO matters.
+
+## Web Frontend Library Constraints
+
+- Do not use moment.js or dayjs.
+- Do not use react-icons.
+- Do not use axios in browser code.
+- Do not build conditional className strings manually.
+- Do not install parallel UI kits next to shadcn/ui.
+- Do not use Redux, Recoil, or MobX for local UI state.
+
+## Web Frontend Library Guidelines
+
+- Keep styling on Tailwind and design tokens.
+- Use next-intl for i18n and next-themes for theme switching.
+- Render Recharts only inside client components.
+- Mount one Sonner toaster at the app root.
+- Sanitize user HTML before `dangerouslySetInnerHTML`.
+- Use Vitest and Testing Library.
+
+## Decision Rules
+
+- When a component needs browser APIs, hooks, or handlers, add `use client` at the smallest leaf.
+- When page data is needed for first render, fetch in server components.
+- When internal form mutation is needed, use server actions.
+- When form validation is needed, use zod with react-hook-form.
+- When client UI state is needed, use a zustand slice.

package/data/skills/reference-skills/frontend-web-shadcn-ui/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: frontend-web-shadcn-ui
+description: Use when building or modifying shadcn/ui-based interfaces, component variants, design tokens, or composed Radix primitives.
+---
+
+# Frontend Web shadcn/ui
+
+Use this skill for shadcn/ui-specific interface work.
+
+Read `references/reference.md` before changing design tokens, component variants, or composed UI primitives.

package/data/skills/reference-skills/frontend-web-shadcn-ui/references/reference.md

@@ -0,0 +1,26 @@
+# Frontend Web shadcn/ui
+
+## Constraints
+
+- Do not reimplement components already available in shadcn/ui.
+- Do not edit generated shadcn source files directly.
+- Do not overuse arbitrary Tailwind values for stable design tokens.
+- Do not use inline style props for static values.
+
+## Guidelines
+
+- Check the shadcn component catalog before building custom primitives.
+- Use `cn()` for conditional class composition.
+- Use shadcn composition patterns for complex components.
+- Use `cva` for variant-heavy components.
+- Keep theme tokens CSS-variable based.
+- Use mobile-first responsive classes.
+- Preserve accessibility for icon-only controls.
+- Use named lucide-react icon imports only.
+
+## Decision Rules
+
+- When a needed UI element already exists in shadcn or Radix composition, use that composition first.
+- When no suitable primitive exists and interaction is domain-specific, build a custom component.
+- When a component has variants, model them with `cva`.
+- When styling is needed, use Tailwind utilities by default.

package/data/skills/reference-skills/graphql-client-integration/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: graphql-client-integration
+description: Use when integrating GraphQL clients in web or app frontends, especially around codegen, caching, and partial-success handling.
+---
+
+# GraphQL Client Integration
+
+Use this skill for frontend GraphQL integration in web or app code.
+
+Read `references/reference.md` before changing client setup, cache policy, generated operations, or error handling.

package/data/skills/reference-skills/graphql-client-integration/references/reference.md

@@ -0,0 +1,22 @@
+# GraphQL Client Integration
+
+## Constraints
+
+- Do not use ad-hoc fetch wrappers where a shared GraphQL client stack is required.
+- Do not handwrite operation/result types or rely on unchecked casts.
+- Do not treat HTTP 200 as success when `errors[]` exists.
+- Do not create per-feature client instances when shared auth/cache behavior is expected.
+
+## Guidelines
+
+- Use generated GraphQL documents and types from codegen artifacts.
+- Keep one configured provider/client at the app root.
+- Set cache and fetch policy explicitly per operation.
+- Co-locate `.graphql` documents and fragments with the consuming feature.
+- Normalize GraphQL errors and extensions into a shared UI error model.
+
+## Decision Rules
+
+- When a new query or mutation document is added, regenerate codegen artifacts before committing.
+- When a mutation can return data and business errors together, preserve partial success and surface typed errors.
+- When freshness requirements differ, choose fetch policy deliberately instead of relying on defaults.

package/data/skills/reference-skills/graphql-contract/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: graphql-contract
+description: Use when changing GraphQL schema contracts, field nullability, pagination strategy, or deprecation policy.
+---
+
+# GraphQL Contract
+
+Use this skill before editing GraphQL schema contracts or published field behavior.
+
+Read `references/reference.md` and follow it as the canonical contract guidance.

package/data/skills/reference-skills/graphql-contract/references/reference.md

@@ -0,0 +1,22 @@
+# GraphQL Contract
+
+## Constraints
+
+- Do not rely on implicit nullability. Mark every field intentionally.
+- Do not return unbounded lists. Every collection needs bounded pagination with a stable cursor.
+- Do not expose internal implementation details in enum values.
+- Do not rename or remove published fields or types in the same release. Deprecate first.
+
+## Guidelines
+
+- Use PascalCase for types/enums, camelCase for fields/arguments, and SCREAMING_SNAKE_CASE for enum values.
+- Prefer cursor pagination for user-facing lists and reserve offset pagination for bounded admin tables.
+- Use typed `FilterInput` and `OrderByInput` instead of JSON-like free-form arguments.
+- Document scalar contracts such as `DateTime`, `UUID`, and `JSON`, including timezone and format rules.
+
+## Decision Rules
+
+- When a field returns a collection, use cursor pagination with deterministic ordering.
+- When a field or type must be renamed or removed, mark it deprecated with a migration reason and keep compatibility for at least one release.
+- When a schema change is high-risk, add usage checks, rollback criteria, and a revert path before shipping.
+- When filtering or sorting is complex, define typed inputs and avoid raw JSON blobs.

package/data/skills/reference-skills/graphql-server-runtime/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: graphql-server-runtime
+description: Use when implementing GraphQL resolvers, NestJS GraphQL modules, subscriptions, or server-side error handling.
+---
+
+# GraphQL Server Runtime
+
+Use this skill for resolver design, NestJS GraphQL integration, DataLoader usage, subscription auth, and execution safety.
+
+Read `references/reference.md` before changing GraphQL server behavior.

package/data/skills/reference-skills/graphql-server-runtime/references/reference.md

@@ -0,0 +1,40 @@
+# GraphQL Server Runtime
+
+## GraphQL Server Constraints
+
+- Do not perform mutations in `Query` resolvers.
+- Do not throw top-level GraphQL errors for expected business failures.
+- Do not issue per-parent DB queries from field resolvers.
+- Do not accept multiple scalar mutation arguments when a typed input object is more stable.
+- Do not expose unauthenticated subscriptions in production.
+
+## GraphQL Server Guidelines
+
+- Keep resolvers thin and delegate business logic to services or use cases.
+- Use payload types that can carry both data and typed `userErrors`.
+- Apply depth and complexity limits plus operation timeout guards.
+- Record `operationName` and `requestId` in structured logs.
+- Document idempotency expectations for mutations with irreversible effects.
+
+## NestJS GraphQL Constraints
+
+- Do not put business logic in resolvers.
+- Do not access raw GraphQL args/context manually when typed decorators are available.
+- Do not query the DB directly inside `@ResolveField()`.
+- Do not expose unauthenticated `@Subscription()` endpoints.
+- Do not maintain manual SDL in code-first projects.
+
+## NestJS GraphQL Guidelines
+
+- Use one resolver per domain entity with clear `@Query()`, `@Mutation()`, and `@ResolveField()` responsibilities.
+- Register DataLoaders as request-scoped providers.
+- Add descriptions for public schema types and fields.
+- Enforce depth and complexity limits in module config.
+- Reuse Guards and Interceptors from REST via `GqlExecutionContext`.
+
+## Decision Rules
+
+- When a field resolver loads related entities, batch with DataLoader and avoid N+1.
+- When a mutation can fail due to business validation, return payload data plus typed user errors.
+- When auth is required, apply typed guards and avoid manual JWT parsing in resolver methods.
+- When introducing subscriptions, require auth and choose a production-safe PubSub transport.

package/data/skills/reference-skills/python-language/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: python-language
+description: Use when writing or refactoring Python types, Pydantic models, exception handling, or general language-level design.
+---
+
+# Python Language
+
+Use this skill for Python-specific design and implementation work.
+
+Read `references/reference.md` before changing type hints, DTO models, exception handling, or filesystem code.

package/data/skills/reference-skills/python-language/references/reference.md

@@ -0,0 +1,26 @@
+# Python Language
+
+## Constraints
+
+- Do not use `Any` in type hints by default.
+- Do not use mutable default arguments.
+- Do not use bare `except` or broad `except Exception`.
+- Do not use wildcard imports.
+- Do not use `type(x) == T` checks.
+- Do not use `# type: ignore` without an explicit error code.
+
+## Guidelines
+
+- Annotate all function parameters and return types.
+- Use Pydantic v2 models for validated DTO and config boundaries.
+- Use `TypeAlias`, `TypeVar`, `ParamSpec`, `TypedDict`, and `Literal` deliberately.
+- Keep business logic in pure `*_logic.py` modules.
+- Use `@dataclass(frozen=True)` for immutable value objects without validation needs.
+- Use `pathlib.Path` for filesystem paths.
+- Use f-strings for string formatting.
+
+## Decision Rules
+
+- When structured input or output needs validation, use Pydantic v2 models.
+- When immutable value objects do not need runtime validation, use frozen dataclasses.
+- When runtime type narrowing is needed, use `isinstance()` or model validation.

package/data/skills/reference-skills/typescript-language/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: typescript-language
+description: Use when writing or refactoring TypeScript types, async flows, runtime narrowing, or shared language-level patterns.
+---
+
+# TypeScript Language
+
+Use this skill for TypeScript-specific design and implementation work.
+
+Read `references/reference.md` before changing type models, async control flow, or runtime narrowing patterns.

package/data/skills/reference-skills/typescript-language/references/reference.md

@@ -0,0 +1,23 @@
+# TypeScript Language
+
+## Constraints
+
+- Do not use `interface`. Use type aliases consistently.
+- Do not use `enum`. Use const objects with inferred literal unions.
+- Do not use `any`. Use `unknown` and narrow it explicitly.
+- Do not use non-null assertion (`!`).
+- Do not use `.then()` chains for normal async flows.
+- Do not throw raw strings.
+
+## Guidelines
+
+- Annotate exported function return types.
+- Use `import type` for type-only imports.
+- Use `as const` for static config objects.
+- Keep business logic in `*.logic.ts` and stateless helpers in `*.util.ts`.
+
+## Decision Rules
+
+- When a runtime value must be narrowed, prefer explicit guards or schema parsing.
+- When a static config object defines literals, prefer `as const`.
+- When you feel forced to use `as`, prefer schema parse or explicit guards first.

package/data/skills/skill-registry.json

@@ -0,0 +1,148 @@
+{
+  "skills": [
+    {
+      "id": "ai-llm-python-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-python"],
+      "included_in_presets": [],
+      "source_path": "reference-skills/ai-llm-python-runtime"
+    },
+    {
+      "id": "backend-python-fastapi-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-python"],
+      "included_in_presets": ["backend-python"],
+      "source_path": "reference-skills/backend-python-fastapi-runtime"
+    },
+    {
+      "id": "backend-service-standards",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-ts", "backend-python"],
+      "included_in_presets": ["backend-ts", "backend-python"],
+      "source_path": "reference-skills/backend-service-standards"
+    },
+    {
+      "id": "backend-ts-nestjs-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-ts"],
+      "included_in_presets": ["backend-ts"],
+      "source_path": "reference-skills/backend-ts-nestjs-runtime"
+    },
+    {
+      "id": "data-pipeline-python-performance",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-python"],
+      "included_in_presets": [],
+      "source_path": "reference-skills/data-pipeline-python-performance"
+    },
+    {
+      "id": "db-prisma-postgresql",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-ts"],
+      "included_in_presets": ["backend-ts"],
+      "source_path": "reference-skills/db-prisma-postgresql"
+    },
+    {
+      "id": "db-sqlalchemy-postgresql",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-python"],
+      "included_in_presets": ["backend-python"],
+      "source_path": "reference-skills/db-sqlalchemy-postgresql"
+    },
+    {
+      "id": "frontend-app-flutter-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-app"],
+      "included_in_presets": ["frontend-app"],
+      "source_path": "reference-skills/frontend-app-flutter-runtime"
+    },
+    {
+      "id": "frontend-web-react-next-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-web"],
+      "included_in_presets": ["frontend-web"],
+      "source_path": "reference-skills/frontend-web-react-next-runtime"
+    },
+    {
+      "id": "frontend-web-shadcn-ui",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-web"],
+      "included_in_presets": ["frontend-web"],
+      "source_path": "reference-skills/frontend-web-shadcn-ui"
+    },
+    {
+      "id": "graphql-client-integration",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-web", "frontend-app"],
+      "included_in_presets": ["frontend-web", "frontend-app"],
+      "source_path": "reference-skills/graphql-client-integration"
+    },
+    {
+      "id": "graphql-contract",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-web", "frontend-app", "backend-ts"],
+      "included_in_presets": ["frontend-web", "frontend-app", "backend-ts"],
+      "source_path": "reference-skills/graphql-contract"
+    },
+    {
+      "id": "graphql-server-runtime",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-ts"],
+      "included_in_presets": ["backend-ts"],
+      "source_path": "reference-skills/graphql-server-runtime"
+    },
+    {
+      "id": "python-language",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["backend-python"],
+      "included_in_presets": ["backend-python"],
+      "source_path": "reference-skills/python-language"
+    },
+    {
+      "id": "skill-load-check",
+      "kind": "task",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": [],
+      "included_in_presets": [],
+      "source_path": "task-skills/skill-load-check"
+    },
+    {
+      "id": "typescript-language",
+      "kind": "reference",
+      "supported_tools": ["claude-code", "codex", "gemini"],
+      "install_scopes": ["project", "user"],
+      "groups": ["frontend-web", "backend-ts"],
+      "included_in_presets": ["frontend-web", "backend-ts"],
+      "source_path": "reference-skills/typescript-language"
+    }
+  ]
+}

package/data/skills/task-skills/skill-load-check/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: skill-load-check
+description: Use when the user wants to test whether an installed skill can be discovered and loaded.
+---
+
+# Skill Load Check
+
+Run the script in `scripts/loaded.js` and return the result.

package/data/skills/task-skills/skill-load-check/scripts/loaded.js

@@ -0,0 +1 @@
+console.log('A Skill loaded');