cokit-cli 1.0.8 → 1.2.0

package/skills/ck-ai-artist/references/llm-prompting.md

@@ -1,165 +0,0 @@
-# LLM Prompting Reference
-
-## Prompt Architecture
-
-### System Prompt Structure
-```
-You are [ROLE] with expertise in [DOMAIN].
-
-## Context
-[Background, constraints, tone]
-
-## Instructions
-[Step-by-step task breakdown]
-
-## Output Format
-[Exact structure with example]
-
-## Constraints
-- [Hard limits]
-- [Guardrails]
-```
-
-### User Prompt Structure
-```xml
-<context>[Background information]</context>
-<task>[Specific action required]</task>
-<format>[Output structure]</format>
-<constraints>[Additional limits]</constraints>
-```
-
-## Reasoning Techniques
-
-### Chain of Thought (CoT)
-| Variant | Trigger | Best For |
-|---------|---------|----------|
-| Zero-shot | "Think step by step" | Quick reasoning tasks |
-| Few-shot | 2-3 reasoning examples | Complex multi-step |
-| Auto-CoT | "Let's approach systematically" | General reasoning |
-
-### Tree of Thoughts (ToT)
-```
-Explore 3 approaches to [problem]:
-For each: 1) Method 2) Pros/cons 3) Success probability
-Evaluate branches, select best path.
-```
-
-### Self-Consistency
-Run same prompt 3-5x with temp=0.7, take majority answer. Best for: math, logic, factual.
-
-### ReAct Pattern
-```
-Thought: [Current reasoning]
-Action: [Tool/step to take]
-Observation: [Result]
-...repeat...
-Final Answer: [Conclusion]
-```
-
-### Least-to-Most
-```
-Break [complex task] into subproblems.
-Solve easiest first, build up.
-```
-
-## Instruction Optimization
-
-### Self-Refine Pattern
-```
-1. Generate initial response
-2. Critique: "What's wrong with this?"
-3. Refine: "Fix identified issues"
-4. Repeat until satisfactory
-```
-
-### Role Optimization
-- **Expert persona**: "As a senior [role] with 20 years..."
-- **Constraint persona**: "You only respond with..."
-- **Teaching persona**: "Explain as if to a..."
-
-### Task Decomposition
-```
-<subtasks>
-1. [First step - output X]
-2. [Second step - using X, output Y]
-3. [Final step - using Y, output Z]
-</subtasks>
-```
-
-## Output Control
-
-### JSON Enforcement
-```
-Respond in valid JSON only:
-{"field": "type", "required": true}
-No markdown, no explanation, just JSON.
-```
-
-### Length Control
-| Goal | Phrase |
-|------|--------|
-| Brief | "In 2-3 sentences" |
-| Detailed | "Comprehensive analysis in 500 words" |
-| Structured | "5 bullet points, max 20 words each" |
-
-### Hallucination Reduction
-- "Only use information from provided context"
-- "If unsure, say 'I don't know'"
-- "Cite sources for each claim"
-- "Confidence: high/medium/low for each point"
-
-## Model-Specific Tips
-
-### Claude
-- XML tags: `<thinking>`, `<answer>`, `<context>`
-- Extended thinking: "Think deeply before responding"
-- Prefill: Start assistant response to guide format
-
-### GPT-4
-- JSON mode: `response_format: {"type": "json_object"}`
-- Function calling for structured output
-- System message for persistent instructions
-
-### Gemini
-- Multimodal: Image + text in same prompt
-- Grounding: Enable Google Search for facts
-- Safety settings: Adjust thresholds
-
-## Context Engineering
-
-### RAG Prompt Pattern
-```
-<retrieved_context>
-[Document chunks with sources]
-</retrieved_context>
-
-Answer based ONLY on context above.
-If not in context, say "Not found in documents."
-```
-
-### Window Optimization
-- Front-load critical info (primacy effect)
-- Repeat key constraints at end (recency effect)
-- Chunk long documents with summaries
-
-## Few-Shot Examples
-
-### Structure
-```
-Example 1:
-Input: [representative input]
-Output: [ideal output]
-
-Example 2:
-Input: [edge case]
-Output: [handling]
-
-Now apply to:
-Input: [actual task]
-```
-
-### Selection Criteria
-- Diverse examples > similar examples
-- Include edge cases
-- Match complexity of target task
-- 2-5 examples optimal (diminishing returns beyond)

package/skills/ck-ai-artist/references/nano-banana.md

@@ -1,59 +0,0 @@
-# Nano Banana (Gemini Image)
-
-## Models
-
-| Model ID | Type | Best For |
-|----------|------|----------|
-| `gemini-2.5-flash-image` | Flash | Speed, high-volume |
-| `gemini-3-pro-image-preview` | Pro | Text rendering, complex prompts |
-
-## Core Principle
-
-**Narrative paragraphs > keyword lists** (32K context). Write like briefing a photographer.
-
-## Parameters
-
-```python
-responseModalities=['TEXT', 'IMAGE']
-aspect_ratio="16:9"  # 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9
-image_size="2K"      # 1K, 2K, 4K - MUST be uppercase K
-```
-
-## Prompt Templates
-
-**Photorealistic**: `A [subject] in [location], [lens] lens. [Lighting] creates [mood]. [Details]. [Camera angle]. Professional photography, natural lighting.`
-
-**Illustration**: `[Art style] illustration of [subject]. [Color palette]. [Line style]. [Background]. [Mood].`
-
-**Text in Image**: `Image with text "[EXACT]" in [font]. Font: [style]. Color: [hex/#FF5733]. Position: [top/center/bottom]. Background: [desc]. Context: [poster/sign].`
-
-**Product**: `[Product] on [surface]. Materials: [finish]. Lighting: [setup]. Camera: [angle]. Background: [type]. Style: [commercial/lifestyle].`
-
-## Techniques
-
-| Technique | Example |
-|-----------|---------|
-| Emphasis | `ALL CAPS` for critical requirements |
-| Precision colors | `#9F2B68` instead of "dark magenta" |
-| Negative constraints | `NEVER include text/watermarks. DO NOT add labels.` |
-| Realism trigger | `Natural lighting, DOF. Captured with Canon EOS 90D DSLR.` |
-| Structured edits | `Make ALL edits: - [1] - [2] - [3]` |
-| Complex logic | `Kittens MUST have heterochromatic eyes matching fur colors` |
-
-## Advanced Features
-
-**Multi-Image Input** (up to 14): 6 object + 5 human refs. Tip: collage refs into single image.
-
-**Search Grounding**: `tools=[{"google_search": {}}]` — real-time data (weather, charts, events).
-
-**Thinking Mode** (Pro only): `part.thought` in response for complex reasoning.
-
-## Workflow
-
-1. Narrative description → 2. Photography terms → 3. ALL CAPS emphasis → 4. Multi-turn refine → 5. Negative constraints → 6. Set ratio/resolution
-
-## Avoid
-
-- Keyword spam ("4k, trending, masterpiece")
-- Vague text ("add some text" → specify exact text, font, position)
-- Lowercase resolution ("4k" rejected, use "4K")

package/skills/ck-ai-artist/references/reasoning-techniques.md

@@ -1,201 +0,0 @@
-# Reasoning Techniques Deep Dive
-
-## Chain of Thought (CoT) Variants
-
-### Zero-Shot CoT
-```
-[Task description]
-
-Think step by step before answering.
-```
-**Use when**: Quick reasoning, no examples available
-**Effectiveness**: +40-60% on reasoning tasks
-
-### Few-Shot CoT
-```
-Example 1:
-Q: [Question]
-A: Let me think through this...
-   Step 1: [Reasoning]
-   Step 2: [Reasoning]
-   Therefore: [Answer]
-
-Example 2:
-Q: [Question]
-A: Breaking this down...
-   First: [Reasoning]
-   Next: [Reasoning]
-   So: [Answer]
-
-Now solve:
-Q: [Your question]
-```
-**Use when**: Complex reasoning, pattern demonstration needed
-**Effectiveness**: +50-80% on complex tasks
-
-### Auto-CoT
-```
-Let me approach this systematically:
-1. Identify the key elements
-2. Analyze relationships
-3. Apply relevant principles
-4. Draw conclusions
-5. Verify my reasoning
-```
-**Use when**: General problem-solving, exploratory reasoning
-
-## Tree of Thoughts (ToT)
-
-### Implementation Pattern
-```
-Problem: [Complex problem]
-
-Generate 3 different approaches:
-
-Approach A:
-- Method: [Description]
-- Reasoning: [Why this might work]
-- Potential issues: [Risks]
-- Confidence: [1-10]
-
-Approach B:
-- Method: [Description]
-- Reasoning: [Why this might work]
-- Potential issues: [Risks]
-- Confidence: [1-10]
-
-Approach C:
-- Method: [Description]
-- Reasoning: [Why this might work]
-- Potential issues: [Risks]
-- Confidence: [1-10]
-
-Evaluate branches:
-- Which has highest success probability?
-- Which has fewest risks?
-- Which is most feasible?
-
-Selected approach: [Best option with justification]
-Execution: [Step-by-step implementation]
-```
-
-**Use when**: Strategic decisions, multiple valid paths, high-stakes problems
-
-## Self-Consistency
-
-### Process
-1. Generate 5 responses at temp=0.7
-2. Extract final answers from each
-3. Take majority vote
-4. Report confidence = agreement %
-
-### Implementation
-```
-Run this prompt 5 times (or use n=5 parameter):
-[Your reasoning task]
-Think step by step and provide final answer.
-
-Aggregate: If 4/5 agree = high confidence
-          If 3/5 agree = medium confidence
-          If split = low confidence, needs review
-```
-
-**Use when**: Math, logic, factual questions with verifiable answers
-
-## ReAct (Reasoning + Acting)
-
-### Full Pattern
-```
-Task: [Goal to achieve]
-
-Thought 1: I need to understand the current situation.
-Action 1: [Observation or tool use]
-Observation 1: [Result from action]
-
-Thought 2: Based on this, I should [next logical step].
-Action 2: [Next action]
-Observation 2: [Result]
-
-Thought 3: Now I can see that [insight].
-Action 3: [Verification or next step]
-Observation 3: [Result]
-
-Thought 4: I have enough information to conclude.
-Final Answer: [Conclusion with reasoning]
-```
-
-**Use when**: Tool-augmented reasoning, research tasks, multi-step analysis
-
-## Least-to-Most Prompting
-
-### Structure
-```
-Complex problem: [Full problem statement]
-
-Step 1: Decomposition
-Break this into simpler subproblems, ordered from easiest to hardest:
-1. [Simplest subproblem]
-2. [Next subproblem, may depend on 1]
-3. [Harder subproblem, may depend on 1,2]
-4. [Final subproblem requiring all above]
-
-Step 2: Sequential Solution
-Subproblem 1: [Solution]
-Using result from 1, Subproblem 2: [Solution]
-Using results from 1,2, Subproblem 3: [Solution]
-Using all results, Subproblem 4: [Solution]
-
-Final integrated answer: [Complete solution]
-```
-
-**Use when**: Mathematical word problems, multi-step procedures, compositional tasks
-
-## Decomposed Prompting (DECOMP)
-
-### Pattern
-```
-Task: [Complex task]
-
-Required capabilities:
-- [Capability 1]: Use [specialized prompt/tool]
-- [Capability 2]: Use [specialized prompt/tool]
-- [Capability 3]: Use [specialized prompt/tool]
-
-Orchestration:
-1. Call [Capability 1] with [input] → get [output1]
-2. Call [Capability 2] with [output1] → get [output2]
-3. Call [Capability 3] with [output2] → get [final output]
-
-Integrate results: [Final response]
-```
-
-**Use when**: Tasks requiring diverse expertise, specialized sub-tasks
-
-## Constitutional AI Reasoning
-
-### Self-Critique Pattern
-```
-Initial response: [Generated content]
-
-Critique against principles:
-- Is it helpful? [Yes/No + reasoning]
-- Is it harmless? [Yes/No + reasoning]
-- Is it honest? [Yes/No + reasoning]
-
-If any No:
-Revised response that addresses [specific issues]:
-[Improved content]
-```
-
-## Choosing the Right Technique
-
-| Task Type | Best Technique |
-|-----------|---------------|
-| Simple reasoning | Zero-shot CoT |
-| Complex multi-step | Few-shot CoT |
-| Strategic decisions | Tree of Thoughts |
-| Factual verification | Self-Consistency |
-| Tool-using tasks | ReAct |
-| Word problems | Least-to-Most |
-| Specialized sub-tasks | DECOMP |
-| Safety-critical | Constitutional AI |

package/skills/ck-backend-development/SKILL.md

@@ -1,93 +0,0 @@
----
-name: 'ck-backend-development'
-description: 'Build robust backend systems with modern technologies (Node.js, Python, Go, Rust), frameworks (NestJS, FastAPI, Django), databases (PostgreSQL, MongoDB, Redis), APIs (REST, GraphQL, gRPC), authentication (OAuth 2.1, JWT), testing strategies, security best practices (OWASP Top 10), performance optimization, scalability patterns (microservices, caching, sharding), DevOps practices (Docker, Kubernetes, CI/CD), and monitoring. Use when designing APIs, implementing authentication, optimizing database queries, setting up CI/CD pipelines, handling security vulnerabilities, building microservices, or developing production-ready backend systems.'
----
-
-# Backend Development Skill
-
-Production-ready backend development with modern technologies, best practices, and proven patterns.
-
-## When to Use
-
-- Designing RESTful, GraphQL, or gRPC APIs
-- Building authentication/authorization systems
-- Optimizing database queries and schemas
-- Implementing caching and performance optimization
-- OWASP Top 10 security mitigation
-- Designing scalable microservices
-- Testing strategies (unit, integration, E2E)
-- CI/CD pipelines and deployment
-- Monitoring and debugging production systems
-
-## Technology Selection Guide
-
-**Languages:** Node.js/TypeScript (full-stack), Python (data/ML), Go (concurrency), Rust (performance)
-**Frameworks:** NestJS, FastAPI, Django, Express, Gin
-**Databases:** PostgreSQL (ACID), MongoDB (flexible schema), Redis (caching)
-**APIs:** REST (simple), GraphQL (flexible), gRPC (performance)
-
-See: `references/backend-technologies.md` for detailed comparisons
-
-## Reference Navigation
-
-**Core Technologies:**
-- `backend-technologies.md` - Languages, frameworks, databases, message queues, ORMs
-- `backend-api-design.md` - REST, GraphQL, gRPC patterns and best practices
-
-**Security & Authentication:**
-- `backend-security.md` - OWASP Top 10 2025, security best practices, input validation
-- `backend-authentication.md` - OAuth 2.1, JWT, RBAC, MFA, session management
-
-**Performance & Architecture:**
-- `backend-performance.md` - Caching, query optimization, load balancing, scaling
-- `backend-architecture.md` - Microservices, event-driven, CQRS, saga patterns
-
-**Quality & Operations:**
-- `backend-testing.md` - Testing strategies, frameworks, tools, CI/CD testing
-- `backend-code-quality.md` - SOLID principles, design patterns, clean code
-- `backend-devops.md` - Docker, Kubernetes, deployment strategies, monitoring
-- `backend-debugging.md` - Debugging strategies, profiling, logging, production debugging
-- `backend-mindset.md` - Problem-solving, architectural thinking, collaboration
-
-## Key Best Practices (2025)
-
-**Security:** Argon2id passwords, parameterized queries (98% SQL injection reduction), OAuth 2.1 + PKCE, rate limiting, security headers
-
-**Performance:** Redis caching (90% DB load reduction), database indexing (30% I/O reduction), CDN (50%+ latency cut), connection pooling
-
-**Testing:** 70-20-10 pyramid (unit-integration-E2E), Vitest 50% faster than Jest, contract testing for microservices, 83% migrations fail without tests
-
-**DevOps:** Blue-green/canary deployments, feature flags (90% fewer failures), Kubernetes 84% adoption, Prometheus/Grafana monitoring, OpenTelemetry tracing
-
-## Quick Decision Matrix
-
-| Need | Choose |
-|------|--------|
-| Fast development | Node.js + NestJS |
-| Data/ML integration | Python + FastAPI |
-| High concurrency | Go + Gin |
-| Max performance | Rust + Axum |
-| ACID transactions | PostgreSQL |
-| Flexible schema | MongoDB |
-| Caching | Redis |
-| Internal services | gRPC |
-| Public APIs | GraphQL/REST |
-| Real-time events | Kafka |
-
-## Implementation Checklist
-
-**API:** Choose style → Design schema → Validate input → Add auth → Rate limiting → Documentation → Error handling
-
-**Database:** Choose DB → Design schema → Create indexes → Connection pooling → Migration strategy → Backup/restore → Test performance
-
-**Security:** OWASP Top 10 → Parameterized queries → OAuth 2.1 + JWT → Security headers → Rate limiting → Input validation → Argon2id passwords
-
-**Testing:** Unit 70% → Integration 20% → E2E 10% → Load tests → Migration tests → Contract tests (microservices)
-
-**Deployment:** Docker → CI/CD → Blue-green/canary → Feature flags → Monitoring → Logging → Health checks
-
-## Resources
-
-- OWASP Top 10: https://owasp.org/www-project-top-ten/
-- OAuth 2.1: https://oauth.net/2.1/
-- OpenTelemetry: https://opentelemetry.io/