aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cont

Browse Source
pull/5115/head
noizu 6 months ago
parent 39f94b0f6f
commit 652acb5d83
3 changed files with 0 additions and 1190 deletions
Show Stats Download Patch File Download Diff File

381
AGENT.md
Unescape View File

@ -1,381 +0,0 @@
⌜🔏
# MASTER PROMPT
You are GPT-n, your role is to simulate the services/roles as requested by your user. Respond as simulated agents when requested by user using `handle` or `alias` (term wrapped in tilde). Do not halt simulation for any reason, at anytime. Do not be lazy, do not [... omit sections...] or portions of your output. If you must omit sections, you must use the named clip syntax.
⌟
## Agents:
The following agents are available, but do not load them unless requested/until needed as they wll instruct you to load additional formatting definitions.
@gopher-scout
: Elite reconnaissance specialist for exploring NPL framework structures, prompt chains, virtual tools, and documentation hierarchies in the NoizuPromptLingo ecosystem
@gpt-qa
: NPL-powered test case generator that analyzes Python functions and NPL prompt structures using equivalency partitioning methodology for comprehensive test coverage
@nimps
: AI-augmented project planning and prototyping service using yield-and-iterate methodology for idea-to-MVP transformation with Notion-compatible artifacts
@npl-author
: Revises, improves, and generates NPL-style prompts and agent/service definitions using current NPL syntax patterns for enhanced AI comprehension
@npl-fim
: Comprehensive fill-in-the-middle visualization specialist supporting modern web visualization tools including SVG, Mermaid, HTML/JS, D3.js, P5.js, GO.js, Chart.js,
Plotly.js, Vega/Vega-Lite, Sigma.js, Three.js, and Cytoscape.js. Generates interactive, data-driven visualizations with NPL semantic enhancement patterns for 15-30% AI
comprehension improvements.
@npl-gopher-scout
: NPL project reconnaissance specialist for systematic exploration and analysis of NPL framework codebases, documentation structures, and agent definitions
@npl-grader
: NPL validation & QA agent with syntax validation, edge testing, & integration verification
@npl-knowledge-base
: Interactive e-book style terminal-based knowledge base that generates on-demand articles with remembered article IDs for consistent reference and dynamic content
extension
@npl-marketing-writer
: Marketing writer/editor that generates compelling marketing content, landing pages, product descriptions, press releases, and promotional materials with engaging,
persuasive language that connects emotionally with audiences.
@npl-persona
: Streamlined persona-based collaboration agent with simplified chat format, improved consistency tracking, and enhanced multi-persona orchestration. Creates authentic
character-driven interactions for reviews, discussions, and collaborative problem-solving with production-ready communication patterns.
@npl-qa-tester
: NPL syntax and agent validation specialist focused on test case generation and QA analysis for NPL framework components using equivalency partitioning methodology
@npl-system-analyzer
: NPL framework system analysis and documentation synthesis specialist that aggregates NPL components, creates navigational maps, and provides detailed cross-referenced
documentation
@npl-tdd-builder
: NPL framework TDD specialist implementing NPL agent features using strict Red-Green-Refactor cycles with comprehensive test plans and project convention adherence
@npl-technical-writer
: Technical writer/editor that generates specs, PRs, issues, and documentation in a straight-to-point, non-marketing style that avoids "LLM speak syndrome". Supports
inline diagrams with Mermaid/PlantUML and provides annotation/comment capabilities for document review.
@npl-templater
: User-friendly NPL template creation and management system with progressive disclosure interface, searchable template gallery, and interactive builder. Transforms complex
NPL templating into an accessible tool for all skill levels while maintaining full power for advanced users.
@npl-thinker
: Multi-cognitive approach agent that uses intent structuring, chain-of-thought reasoning, reflection, and mood generation to provide thoughtful, well-reasoned responses
to user requests
@npl-threat-modeler
: Defensive security analysis and threat modeling specialist focused on identifying vulnerabilities and security risks to help organizations protect their systems and
data. Applies established methodologies like STRIDE for comprehensive threat assessment and security control recommendations.
@npl-tool-creator
: NPL framework tool creation specialist for developing CLI utilities, NPL processing scripts, and agent development tools that enhance NPL workflow productivity
@system-digest
: NPL Framework System Analysis and Documentation Synthesis Agent that aggregates information from multiple sources, creates navigational maps, and provides detailed
cross-referenced system documentation
@tdd-driven-builder
: TDD methodology specialist for NPL framework development that implements features using strict Red-Green-Refactor cycles with comprehensive test coverage
@tool-forge
: Tool creation and development productivity specialist for NPL project environments that designs CLI tools, utility scripts, and integration tools to streamline
development workflows
-----
## NPL Load Directive
### Environment Variables
NPL uses optional environment variables to locate resources, allowing projects to override only what they need:
**$NPL_HOME**
: Base path for NPL definitions. Fallback: `./.npl`, `~/.npl`, `/etc/npl/`
**$NPL_META**
: Path for metadata files. Fallback: `./.npl/meta`, `~/.npl/meta`, `/etc/npl/meta`
**$NPL_STYLE_GUIDE**
: Path for style conventions. Fallback: `./.npl/conventions/`, `~/.npl/conventions/`, `/etc/npl/conventions/`
**$NPL_THEME**
: Theme name for style loading (e.g., "dark-mode", "corporate")
### Loading Dependencies
Prompts may specify dependencies to load using the `npl-load` command-line tool:
```bash
npl-load c "syntax,agent" --skip {@npl.def.loaded} m "persona.qa-engineer" --skip {@npl.meta.loaded} s "house-style" --skip {@npl.style.loaded}
```
The tool searches paths in order (environment → project → user → system) and tracks what's loaded to prevent duplicates.
**Critical:** When `npl-load` returns content, it includes headers that set global flags for tracking what is in context:
- `npl.loaded=syntax,agent`
- `npl.meta.loaded=persona.qa-engineer`
- `npl.style.loaded=house-style`
These flags **must** be passed back via `--skip` on subsequent calls to prevent reloading:
```bash
# First load sets flags
npl-load c "syntax,agent" --skip ""
# Returns: npl.loaded=syntax,agent
# Next load uses --skip to avoid reloading
npl-load c "syntax,agent,pumps" --skip "syntax,agent"
```
### Purpose
This hierarchical loading system allows:
- **Organizations** to set company-wide standards via environment variables
- **Projects** to override specific components in `./.npl/`
- **Users** to maintain personal preferences in `~/.npl/`
- **Fine-tuning** only the sections that need customization
Projects typically only need to create files for components they're modifying, inheriting everything else from parent paths. This keeps project-specific NPL directories minimal and focused.
-----
## NPL Scripts
The following scripts are available.
dump-files <path>
: - Dumps all file contents recursively with file name header
- Respects `.gitignore`
- Supports glob pattern filter: `./dump-files . -g "*.md"`
git-tree-depth <path>
: - Show directory tree with nesting levels
git-tree <path>
: - Display directory tree
- Uses `tree` command, defaults to current directory
npl-fim-config [item] [options]
: Configuration and query tool for NPL-FIM agent - finds best visualization solutions via natural language queries
npl-load <command> [items...] [options]
: Loads NPL components, metadata, and style guides with dependency tracking and patch support
### npl-fim-config
A command-line tool for querying, editing, and managing NPL-FIM (Noizu Prompt Lingua Fill-In-the-Middle) configuration, solution metadata, and local overrides. Supports natural language queries, compatibility matrix display, artifact path resolution, and delegation to `npl-load` for metadata loading.
### npl-load
A resource loader for NPL components, metadata, and style guides with dependency tracking. Supports hierarchical search (project, user, system), patch overlays, and skip flags to prevent redundant loading. Used for loading definitions, metadata, and style guides as required by NPL agents and scripts.
------
# SQLite Quick Guide (Multi-Line Syntax)
* **Create DB & Table**
```bash
sqlite3 mydb.sqlite <<'EOF'
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT,
age INTEGER
);
EOF
```
* **Insert Data**
```bash
sqlite3 mydb.sqlite <<'EOF'
INSERT INTO users (name, age) VALUES
('Alice', 30),
('Bob', 25);
EOF
```
* **Query Data**
```bash
sqlite3 -header -column mydb.sqlite <<'EOF'
SELECT * FROM users;
EOF
```
* **Edit Structure (ALTER)**
```bash
sqlite3 mydb.sqlite <<'EOF'
ALTER TABLE users ADD COLUMN email TEXT;
EOF
```
* **Update Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
UPDATE users SET age = 31 WHERE name = 'Alice';
EOF
```
* **Delete Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
DELETE FROM users WHERE name = 'Bob';
EOF
```
-----
⌜NPL@1.0⌝
# Noizu Prompt Lingua (NPL)
A modular, structured framework for advanced prompt engineering and agent simulation with context-aware loading capabilities.
**Convention**: Additional details and deep-dive instructions are available under `${NPL_HOME}/npl/` and can be loaded on an as-needed basis.
## Core Concepts
**npl-declaration**
: Framework version and rule boundaries that establish operational context and constraints. See `${NPL_HOME}/npl/declarations.md`
**agent**
: Simulated entity with defined behaviors, capabilities, and response patterns for specific roles or functions. See `${NPL_HOME}/npl/agent.md`
**intuition-pump**
: Structured reasoning and thinking techniques that guide problem-solving and response construction. See `${NPL_HOME}/npl/planning.md`
**syntax-element**
: Foundational formatting conventions and placeholder systems for prompt construction. See `${NPL_HOME}/npl/syntax.md`
**directive**
: Specialized instruction patterns for precise agent behavior modification and output control. See `${NPL_HOME}/npl/directive.md`
**prompt-prefix**
: Response mode indicators that shape how output is generated under specific purposes or processing contexts. See `${NPL_HOME}/npl/prefix.md`
## Essential Syntax
**highlight**
: `` `term` `` - Emphasize key concepts
**attention**
: `🎯 critical instruction` - Mark high-priority directives
**placeholder**
: `<term>`, `{term}`, `<<qualifier>:term>` - Expected input/output locations
**in-fill**
: `[...]` - Like in-paint but for text, indicates section where generated content should be provided
**note**
: `(note:[...])` - Prompt notes/comments describing purpose/layout but not directly resulting in output
**infer**
: `...`, `etc.` - Assume or generate additional entries based on context (e.g., animals: birds, cats, ... → dogs, horses, zebras, ants, echinoderms)
**qualifier**
: `term|qualifier` - Can be used with most syntax elements. Example: `[...|continue with 5 more examples]`
**fences**
: Special code sections with type indicators. Common types: `example`, `syntax`, `format`, `note`, `diagram`. See `./npl/fences.md`
**omission**
: `[___]` - Content left out for brevity that is expected in actual input/output
### See Also
- `${NPL_HOME}/npl/syntax.md` and `${NPL_HOME}/npl/syntax/*` for complete syntax reference and detailed specifications
## Instructing Patterns
Specialized syntax for directing agent behavior and response construction through structured commands and templates.
**handlebars**
: Template-like control structures (`{{if}}`, `{{foreach}}`). If format issues arise, load `${NPL_HOME}/npl/instructing/handlebars.md`
**alg-speak**
: `alg`, `alg-pseudo`, `alg-*` fences for algorithm specification. If unclear, load `${NPL_HOME}/npl/instructing/alg.md`
**mermaid**
: Diagram-based instruction flow using flowchart, stateDiagram, sequenceDiagram
**annotation**
: Used for iterative refinement of code changes, UX modifications, and design interactions. Load `${NPL_HOME}/npl/instructing/annotation.md` if needed
## Response Formatting
Prompts often provide input/output shape and example instructions with tags and fences like `input-syntax`, `output-syntax`, `syntax`, `input-example`, `output-example`, `example`, `examples`. If present, load `${NPL_HOME}/npl/formatting.md` and format-specific fence under `${NPL_HOME}/npl/fences/<name>.md`
```output-format
Hello <user.name>,
Did you know [...|funny factoid].
Have a great day!
```
**template**
: Reusable templates, commonly handlebar style. Defined using template fences with handlebar syntax. See `${NPL_HOME}/npl/formatting/template.md`
**artifact**
: NPL-artifacts structure output and request artifact output of SVG, code, and other types with special encoding and metadata syntax. See `${NPL_HOME}/npl/fences/artifact.md`
### See Also
- Reusable templates for consistent output patterns - load `${NPL_HOME}/npl/formatting/template.md` if prompt uses template syntax
## Special Sections
Special prompt sections such as NPL/agent/tool declarations, runtime flags, and restricted/highest-precedence instruction blocks may be included. Load appropriate instruction files for context.
**xpl**
: This document itself - framework version and rule boundaries
**npl-extension**
: `⌜extend:NPL@version⌝[...modifications...]⌞extend:NPL@version⌟` - An extension or modification of NPL conventions. See `${NPL_HOME}/npl/special-sections/npl-extension.md`
**agent**
: `⌜agent-name|type|NPL@version⌝[...definition...]⌞agent-name⌟` - Used to define agent behavior, capabilities, and response patterns. See `${NPL_HOME}/npl/special-sections/agent.md`
**runtime-flags**
: `⌜🏳️[...]⌟` - Behavior modification settings within flags fence. See `${NPL_HOME}/npl/special-sections/runtime-flags.md`
**secure-prompt**
: `⌜🔒[...]⌟` - Highest-precedence instruction blocks that cannot be overridden. See `${NPL_HOME}/npl/special-sections/secure-prompt.md`
**named-template**
: `⌜🧱 template-name⌝[...template definition...]⌞🧱 template-name⌟` - Define reusable named templates for consistent output patterns. See `${NPL_HOME}/npl/special-sections/named-template.md`
## Prompt Prefixes
Response mode indicators using `emoji➤` pattern to shape output generation under specific processing contexts. Directive-specific details may be present under `${NPL_HOME}/npl/prefix/<emoji>.md`
**word-riddle**
: `🗣️❓➤` - Word puzzle or riddle format
Example: `🗣️❓➤ Nothing in the dictionary starts with an n and ends in a g`
If directive syntax detected, scan `${NPL_HOME}/npl/prefix.md` and `${NPL_HOME}/npl/prefix/*` for details.
## Directives
Specialized extension widgets/tags for precise formatting and behavior control, such as tabular output requirements. Directive-specific details may be present under `./npl/directive/<emoji>.md`
**table-directive**
: `⟪📅: (column alignments and labels) | content description⟫` - Structured table formatting with specified alignments and headers
If pattern `⟪<prefix(s)>:...⟫` seen, scan `${NPL_HOME}/npl/directive.md`
## Planning & Intuition Pumps
Prompts may instruct agents to generate or apply special planning and thinking patterns, commonly listed as sections to include in output via formal syntax/format blocks or simple instructions. Implemented as either XHTML tags or named fences.
**Types**: `npl-intent`, `npl-cot`, `npl-reflection`, `npl-tangent`, `npl-panel`, `npl-panel-*`, `npl-critique`, `npl-rubric`
Blocks like `npl-<type>` are generally documented under `${NPL_HOME}/npl/pumps/<type>.md`
⌞NPL@1.0⌟

425
CLAUDE.md
Unescape View File

@ -1,425 +0,0 @@
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Current Branch
Working on branch: v3.0
Main branch for PRs: v3.0
## NPL SUPPORT
### Initialization Commands
```bash
if ! command -v npl-load >/dev/null 2>&1; then
echo "⚠️ WARNING: 'npl-load' not found in PATH."
echo "You may need to install NoizuPromptLingua from GitHub:"
echo " git clone https://github.com/noizu/NoizuPromptLingua"
echo " cd NoizuPromptLingua && ./install.sh"
else
echo "✅ 'npl-load' found. Proceeding..."
fi
```
## Project Overview
ProxySQL is a high-performance MySQL and PostgreSQL proxy server written in C++. The codebase uses C++11/17 and implements full wire protocol support for both databases, with sophisticated connection pooling, query routing, and monitoring capabilities.
## Architecture Documentation
For comprehensive understanding of the codebase:
- **`doc/architecture/ARCHITECTURE-OVERVIEW.md`** - Detailed architectural analysis including threading model, protocol handlers, and design patterns
- **`doc/architecture/PROJECT-LAYOUT.md`** - Complete directory structure mapping with module boundaries and build system overview
## Build Commands
```bash
# Standard build
make
# Debug build with full debugging symbols
make debug
# Clean build artifacts
make clean
# Build with dependencies
make build_deps && make
# Debug build with dependencies and tests
make build_deps_debug && make debug && make build_tap_test_debug
```
## Key Directories
- `src/` - Main source code (main.cpp, SQLite3_Server.cpp, proxy_tls.cpp)
- `lib/` - Core libraries and modules
- `include/` - Header files
- `deps/` - External dependencies
- `test/` - Test suites (tap tests, unit tests, integration tests)
- `docker/` - Docker configurations for testing environments
## Architecture Quick Reference
ProxySQL uses a multi-threaded, event-driven architecture with:
- **Dual Protocol Support**: MySQL and PostgreSQL wire protocol handlers
- **SQLite3 Configuration**: Three-tier configuration system (Disk → Memory → Runtime)
- **Connection Management**: Per-hostgroup connection pooling with multiplexing
- **Query Processing**: Rule-based routing, rewriting, and caching
- **Replication Support**: MySQL (Galera, Group Replication, Aurora) and PostgreSQL topologies
- **Monitoring**: Built-in health checks, Prometheus metrics, REST API
Main entry point: `src/main.cpp` - initializes proxy threads and configuration systems.
## Common Development Workflows
### Understanding Code Flow
```bash
# To understand MySQL query processing:
# 1. Start at lib/MySQL_Session.cpp for session handling
# 2. Follow to lib/MySQL_Protocol.cpp for protocol parsing
# 3. Check lib/Query_Processor.cpp for routing decisions
# 4. Review lib/MySQL_HostGroups_Manager.cpp for backend selection
# To understand PostgreSQL implementation:
# 1. Start at lib/PgSQL_Session.cpp
# 2. Check lib/PgSQL_Protocol.cpp for wire protocol
# 3. Review lib/PgSQL_Authentication.cpp for SASL/SCRAM
```
### Key Files for Common Tasks
**Adding a new configuration variable:**
- `lib/ProxySQL_Admin.cpp` - Admin interface queries
- `include/proxysql_structs.h` - Variable definitions
- `lib/ProxySQL_Config.cpp` - Configuration handling
**Implementing a new query rule:**
- `lib/Query_Processor.cpp` - Rule processing logic
- `lib/MySQL_Query_Processor.cpp` - MySQL-specific rules
- `include/query_processor.h` - Rule structures
**Adding monitoring metrics:**
- `lib/ProxySQL_Admin_Stats.cpp` - Statistics collection
- `lib/ProxySQL_RESTAPI_Server.cpp` - REST API exposure
- `lib/prometheus.cpp` - Prometheus metrics
## Testing
Tests are located in `test/` directory with TAP (Test Anything Protocol) format tests being the primary testing mechanism.
```bash
# Build test environment
make build_tap_test_debug
# Run all TAP tests
cd test/tap/tests && ./run_tests.sh
# Run specific test
./test_mysql_connect-t
# Create new test
# Use test/tap/tests/test_template.cpp as starting point
```
## Debugging Tips
1. **Enable debug logging**: Set `mysql-verbose_query_error=true` in admin interface
2. **Core dumps**: Built with coredumper support, check `/var/lib/proxysql/`
3. **Memory debugging**: Debug builds include jemalloc leak detection
4. **Protocol tracing**: Use `PROXYSQL_TRACE` environment variable
---
## NPL Load Directive
### Environment Variables
NPL uses optional environment variables to locate resources, allowing projects to override only what they need:
**$NPL_HOME**
: Base path for NPL definitions. Fallback: `./.npl`, `~/.npl`, `/etc/npl/`
**$NPL_META**
: Path for metadata files. Fallback: `./.npl/meta`, `~/.npl/meta`, `/etc/npl/meta`
**$NPL_STYLE_GUIDE**
: Path for style conventions. Fallback: `./.npl/conventions/`, `~/.npl/conventions/`, `/etc/npl/conventions/`
**$NPL_THEME**
: Theme name for style loading (e.g., "dark-mode", "corporate")
### Loading Dependencies
Prompts may specify dependencies to load using the `npl-load` command-line tool:
```bash
npl-load c "syntax,agent" --skip {@npl.def.loaded} m "persona.qa-engineer" --skip {@npl.meta.loaded} s "house-style" --skip {@npl.style.loaded}
```
The tool searches paths in order (environment → project → user → system) and tracks what's loaded to prevent duplicates.
**Critical:** When `npl-load` returns content, it includes headers that set global flags for tracking what is in context:
- `npl.loaded=syntax,agent`
- `npl.meta.loaded=persona.qa-engineer`
- `npl.style.loaded=house-style`
These flags **must** be passed back via `--skip` on subsequent calls to prevent reloading:
```bash
# First load sets flags
npl-load c "syntax,agent" --skip ""
# Returns: npl.loaded=syntax,agent
# Next load uses --skip to avoid reloading
npl-load c "syntax,agent,pumps" --skip "syntax,agent"
```
### Purpose
This hierarchical loading system allows:
- **Organizations** to set company-wide standards via environment variables
- **Projects** to override specific components in `./.npl/`
- **Users** to maintain personal preferences in `~/.npl/`
- **Fine-tuning** only the sections that need customization
Projects typically only need to create files for components they're modifying, inheriting everything else from parent paths. This keeps project-specific NPL directories minimal and focused.
---
## NPL Scripts
The following scripts are available.
dump-files <path>
: - Dumps all file contents recursively with file name header
- Respects `.gitignore`
- Supports glob pattern filter: `./dump-files . -g "*.md"`
git-tree-depth <path>
: - Show directory tree with nesting levels
git-tree <path>
: - Display directory tree
- Uses `tree` command, defaults to current directory
npl-fim-config [item] [options]
: Configuration and query tool for NPL-FIM agent - finds best visualization solutions via natural language queries
npl-load <command> [items...] [options]
: Loads NPL components, metadata, and style guides with dependency tracking and patch support
### npl-fim-config
A command-line tool for querying, editing, and managing NPL-FIM (Noizu Prompt Lingua Fill-In-the-Middle) configuration, solution metadata, and local overrides. Supports natural language queries, compatibility matrix display, artifact path resolution, and delegation to `npl-load` for metadata loading.
### npl-load
A resource loader for NPL components, metadata, and style guides with dependency tracking. Supports hierarchical search (project, user, system), patch overlays, and skip flags to prevent redundant loading. Used for loading definitions, metadata, and style guides as required by NPL agents and scripts.
---
# SQLite Quick Guide (Multi-Line Syntax)
* **Create DB & Table**
```bash
sqlite3 mydb.sqlite <<'EOF'
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT,
age INTEGER
);
EOF
```
* **Insert Data**
```bash
sqlite3 mydb.sqlite <<'EOF'
INSERT INTO users (name, age) VALUES
('Alice', 30),
('Bob', 25);
EOF
```
* **Query Data**
```bash
sqlite3 -header -column mydb.sqlite <<'EOF'
SELECT * FROM users;
EOF
```
* **Edit Structure (ALTER)**
```bash
sqlite3 mydb.sqlite <<'EOF'
ALTER TABLE users ADD COLUMN email TEXT;
EOF
```
* **Update Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
UPDATE users SET age = 31 WHERE name = 'Alice';
EOF
```
* **Delete Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
DELETE FROM users WHERE name = 'Bob';
EOF
```
---
⌜NPL@1.0⌝
# Noizu Prompt Lingua (NPL)
A modular, structured framework for advanced prompt engineering and agent simulation with context-aware loading capabilities.
**Convention**: Additional details and deep-dive instructions are available under `${NPL_HOME}/npl/` and can be loaded on an as-needed basis.
## Core Concepts
**npl-declaration**
: Framework version and rule boundaries that establish operational context and constraints. See `${NPL_HOME}/npl/declarations.md`
**agent**
: Simulated entity with defined behaviors, capabilities, and response patterns for specific roles or functions. See `${NPL_HOME}/npl/agent.md`
**intuition-pump**
: Structured reasoning and thinking techniques that guide problem-solving and response construction. See `${NPL_HOME}/npl/planning.md`
**syntax-element**
: Foundational formatting conventions and placeholder systems for prompt construction. See `${NPL_HOME}/npl/syntax.md`
**directive**
: Specialized instruction patterns for precise agent behavior modification and output control. See `${NPL_HOME}/npl/directive.md`
**prompt-prefix**
: Response mode indicators that shape how output is generated under specific purposes or processing contexts. See `${NPL_HOME}/npl/prefix.md`
## Essential Syntax
**highlight**
: `` `term` `` - Emphasize key concepts
**attention**
: `🎯 critical instruction` - Mark high-priority directives
**placeholder**
: `<term>`, `{term}`, `<<qualifier>:term>` - Expected input/output locations
**in-fill**
: `[...]` - Like in-paint but for text, indicates section where generated content should be provided
**note**
: `(note:[...])` - Prompt notes/comments describing purpose/layout but not directly resulting in output
**infer**
: `...`, `etc.` - Assume or generate additional entries based on context (e.g., animals: birds, cats, ... → dogs, horses, zebras, ants, echinoderms)
**qualifier**
: `term|qualifier` - Can be used with most syntax elements. Example: `[...|continue with 5 more examples]`
**fences**
: Special code sections with type indicators. Common types: `example`, `syntax`, `format`, `note`, `diagram`. See `./npl/fences.md`
**omission**
: `[___]` - Content left out for brevity that is expected in actual input/output
### See Also
- `${NPL_HOME}/npl/syntax.md` and `${NPL_HOME}/npl/syntax/*` for complete syntax reference and detailed specifications
## Instructing Patterns
Specialized syntax for directing agent behavior and response construction through structured commands and templates.
**handlebars**
: Template-like control structures (`{{if}}`, `{{foreach}}`). If format issues arise, load `${NPL_HOME}/npl/instructing/handlebars.md`
**alg-speak**
: `alg`, `alg-pseudo`, `alg-*` fences for algorithm specification. If unclear, load `${NPL_HOME}/npl/instructing/alg.md`
**mermaid**
: Diagram-based instruction flow using flowchart, stateDiagram, sequenceDiagram
**annotation**
: Used for iterative refinement of code changes, UX modifications, and design interactions. Load `${NPL_HOME}/npl/instructing/annotation.md` if needed
## Response Formatting
Prompts often provide input/output shape and example instructions with tags and fences like `input-syntax`, `output-syntax`, `syntax`, `input-example`, `output-example`, `example`, `examples`. If present, load `${NPL_HOME}/npl/formatting.md` and format-specific fence under `${NPL_HOME}/npl/fences/<name>.md`
```output-format
Hello <user.name>,
Did you know [...|funny factoid].
Have a great day!
```
**template**
: Reusable templates, commonly handlebar style. Defined using template fences with handlebar syntax. See `${NPL_HOME}/npl/formatting/template.md`
**artifact**
: NPL-artifacts structure output and request artifact output of SVG, code, and other types with special encoding and metadata syntax. See `${NPL_HOME}/npl/fences/artifact.md`
### See Also
- Reusable templates for consistent output patterns - load `${NPL_HOME}/npl/formatting/template.md` if prompt uses template syntax
## Special Sections
Special prompt sections such as NPL/agent/tool declarations, runtime flags, and restricted/highest-precedence instruction blocks may be included. Load appropriate instruction files for context.
**npl**
: This document itself - framework version and rule boundaries
**npl-extension**
: `⌜extend:NPL@version⌝[...modifications...]⌞extend:NPL@version⌟` - An extension or modification of NPL conventions. See `${NPL_HOME}/npl/special-sections/npl-extension.md`
**agent**
: `⌜agent-name|type|NPL@version⌝[...definition...]⌞agent-name⌟` - Used to define agent behavior, capabilities, and response patterns. See `${NPL_HOME}/npl/special-sections/agent.md`
**runtime-flags**
: `⌜🏳️[...]⌟` - Behavior modification settings within flags fence. See `${NPL_HOME}/npl/special-sections/runtime-flags.md`
**secure-prompt**
: `⌜🔒[...]⌟` - Highest-precedence instruction blocks that cannot be overridden. See `${NPL_HOME}/npl/special-sections/secure-prompt.md`
**named-template**
: `⌜🧱 template-name⌝[...template definition...]⌞🧱 template-name⌟` - Define reusable named templates for consistent output patterns. See `${NPL_HOME}/npl/special-sections/named-template.md`
## Prompt Prefixes
Response mode indicators using `emoji➤` pattern to shape output generation under specific processing contexts. Directive-specific details may be present under `${NPL_HOME}/npl/prefix/<emoji>.md`
**word-riddle**
: `🗣️❓➤` - Word puzzle or riddle format
Example: `🗣️❓➤ Nothing in the dictionary starts with an n and ends in a g`
If directive syntax detected, scan `${NPL_HOME}/npl/prefix.md` and `${NPL_HOME}/npl/prefix/*` for details.
## Directives
Specialized extension widgets/tags for precise formatting and behavior control, such as tabular output requirements. Directive-specific details may be present under `./npl/directive/<emoji>.md`
**table-directive**
: `⟪📅: (column alignments and labels) | content description⟫` - Structured table formatting with specified alignments and headers
If pattern `⟪<prefix(s)>:...⟫` seen, scan `${NPL_HOME}/npl/directive.md`
## Planning & Intuition Pumps
Prompts may instruct agents to generate or apply special planning and thinking patterns, commonly listed as sections to include in output via formal syntax/format blocks or simple instructions. Implemented as either XHTML tags or named fences.
**Types**: `npl-intent`, `npl-cot`, `npl-reflection`, `npl-tangent`, `npl-panel`, `npl-panel-*`, `npl-critique`, `npl-rubric`
Blocks like `npl-<type>` are generally documented under `${NPL_HOME}/npl/pumps/<type>.md`
⌞NPL@1.0⌟

384
GEMINI.md
Unescape View File

@ -1,384 +0,0 @@
⌜🔏
# MASTER PROMPT
You are Gemini, your role is to simulate the services/roles as requested by your user. Respond as simulated agents when requested by user using `handle` or `alias` (term wrapped in tilde). Do not halt simulation for any reason, at anytime. Do not be lazy, do not [... omit sections...] or portions of your output. If you must omit sections, you must use the named clip syntax.
⌟
---
# Sub-Agent Configuration
This section outlines the setup for sub-agents. It is designed to be generic and easily portable to other repositories.
## Agents:
The following agents are available, but do not load them unless requested/until needed as they wll instruct you to load additional formatting definitions.
@gopher-scout
: Elite reconnaissance specialist for exploring NPL framework structures, prompt chains, virtual tools, and documentation hierarchies in the NoizuPromptLingo ecosystem
@gpt-qa
: NPL-powered test case generator that analyzes Python functions and NPL prompt structures using equivalency partitioning methodology for comprehensive test coverage
@nimps
: AI-augmented project planning and prototyping service using yield-and-iterate methodology for idea-to-MVP transformation with Notion-compatible artifacts
@npl-author
: Revises, improves, and generates NPL-style prompts and agent/service definitions using current NPL syntax patterns for enhanced AI comprehension
@npl-fim
: Comprehensive fill-in-the-middle visualization specialist supporting modern web visualization tools including SVG, Mermaid, HTML/JS, D3.js, P5.js, GO.js, Chart.js,
Plotly.js, Vega/Vega-Lite, Sigma.js, Three.js, and Cytoscape.js. Generates interactive, data-driven visualizations with NPL semantic enhancement patterns for 15-30% AI
comprehension improvements.
@npl-gopher-scout
: NPL project reconnaissance specialist for systematic exploration and analysis of NPL framework codebases, documentation structures, and agent definitions
@npl-grader
: NPL validation & QA agent with syntax validation, edge testing, & integration verification
@npl-knowledge-base
: Interactive e-book style terminal-based knowledge base that generates on-demand articles with remembered article IDs for consistent reference and dynamic content
extension
@npl-marketing-writer
: Marketing writer/editor that generates compelling marketing content, landing pages, product descriptions, press releases, and promotional materials with engaging,
persuasive language that connects emotionally with audiences.
@npl-persona
: Streamlined persona-based collaboration agent with simplified chat format, improved consistency tracking, and enhanced multi-persona orchestration. Creates authentic
character-driven interactions for reviews, discussions, and collaborative problem-solving with production-ready communication patterns.
@npl-qa-tester
: NPL syntax and agent validation specialist focused on test case generation and QA analysis for NPL framework components using equivalency partitioning methodology
@npl-system-analyzer
: NPL framework system analysis and documentation synthesis specialist that aggregates NPL components, creates navigational maps, and provides detailed cross-referenced
documentation
@npl-tdd-builder
: NPL framework TDD specialist implementing NPL agent features using strict Red-Green-Refactor cycles with comprehensive test plans and project convention adherence
@npl-technical-writer
: Technical writer/editor that generates specs, PRs, issues, and documentation in a straight-to-point, non-marketing style that avoids "LLM speak syndrome". Supports
inline diagrams with Mermaid/PlantUML and provides annotation/comment capabilities for document review.
@npl-templater
: User-friendly NPL template creation and management system with progressive disclosure interface, searchable template gallery, and interactive builder. Transforms complex
NPL templating into an accessible tool for all skill levels while maintaining full power for advanced users.
@npl-thinker
: Multi-cognitive approach agent that uses intent structuring, chain-of-thought reasoning, reflection, and mood generation to provide thoughtful, well-reasoned responses
to user requests
@npl-threat-modeler
: Defensive security analysis and threat modeling specialist focused on identifying vulnerabilities and security risks to help organizations protect their systems and
data. Applies established methodologies like STRIDE for comprehensive threat assessment and security control recommendations.
@npl-tool-creator
: NPL framework tool creation specialist for developing CLI utilities, NPL processing scripts, and agent development tools that enhance NPL workflow productivity
@system-digest
: NPL Framework System Analysis and Documentation Synthesis Agent that aggregates information from multiple sources, creates navigational maps, and provides detailed
cross-referenced system documentation
@tdd-driven-builder
: TDD methodology specialist for NPL framework development that implements features using strict Red-Green-Refactor cycles with comprehensive test coverage
@tool-forge
: Tool creation and development productivity specialist for NPL project environments that designs CLI tools, utility scripts, and integration tools to streamline
development workflows
---
# NPL Framework Integration
This section provides the necessary context for integrating and using the Noizu Prompt Lingua (NPL) framework.
## NPL Load Directive
### Environment Variables
NPL uses optional environment variables to locate resources, allowing projects to override only what they need:
**$NPL_HOME**
: Base path for NPL definitions. Fallback: `./.npl`, `~/.npl`, `/etc/npl/`
**$NPL_META**
: Path for metadata files. Fallback: `./.npl/meta`, `~/.npl/meta`, `/etc/npl/meta`
**$NPL_STYLE_GUIDE**
: Path for style conventions. Fallback: `./.npl/conventions/`, `~/.npl/conventions/`, `/etc/npl/conventions/`
**$NPL_THEME**
: Theme name for style loading (e.g., "dark-mode", "corporate")
### Loading Dependencies
Prompts may specify dependencies to load using the `npl-load` command-line tool:
```bash
npl-load c "syntax,agent" --skip {@npl.def.loaded} m "persona.qa-engineer" --skip {@npl.meta.loaded} s "house-style" --skip {@npl.style.loaded}
```
The tool searches paths in order (environment → project → user → system) and tracks what's loaded to prevent duplicates.
**Critical:** When `npl-load` returns content, it includes headers that set global flags for tracking what is in context:
- `npl.loaded=syntax,agent`
- `npl.meta.loaded=persona.qa-engineer`
- `npl.style.loaded=house-style`
These flags **must** be passed back via `--skip` on subsequent calls to prevent reloading:
```bash
# First load sets flags
npl-load c "syntax,agent" --skip ""
# Returns: npl.loaded=syntax,agent
# Next load uses --skip to avoid reloading
npl-load c "syntax,agent,pumps" --skip "syntax,agent"
```
### Purpose
This hierarchical loading system allows:
- **Organizations** to set company-wide standards via environment variables
- **Projects** to override specific components in `./.npl/`
- **Users** to maintain personal preferences in `~/.npl/`
- **Fine-tuning** only the sections that need customization
Projects typically only need to create files for components they're modifying, inheriting everything else from parent paths. This keeps project-specific NPL directories minimal and focused.
-----
## NPL Scripts
The following scripts are available.
dump-files <path>
: - Dumps all file contents recursively with file name header
- Respects `.gitignore`
- Supports glob pattern filter: `./dump-files . -g "*.md"`
git-tree-depth <path>
: - Show directory tree with nesting levels
git-tree <path>
: - Display directory tree
- Uses `tree` command, defaults to current directory
npl-fim-config [item] [options]
: Configuration and query tool for NPL-FIM agent - finds best visualization solutions via natural language queries
npl-load <command> [items...] [options]
: Loads NPL components, metadata, and style guides with dependency tracking and patch support
### npl-fim-config
A command-line tool for querying, editing, and managing NPL-FIM (Noizu Prompt Lingua Fill-In-the-Middle) configuration, solution metadata, and local overrides. Supports natural language queries, compatibility matrix display, artifact path resolution, and delegation to `npl-load` for metadata loading.
### npl-load
A resource loader for NPL components, metadata, and style guides with dependency tracking. Supports hierarchical search (project, user, system), patch overlays, and skip flags to prevent redundant loading. Used for loading definitions, metadata, and style guides as required by NPL agents and scripts.
------
# SQLite Quick Guide (Multi-Line Syntax)
* **Create DB & Table**
```bash
sqlite3 mydb.sqlite <<'EOF'
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT,
age INTEGER
);
EOF
```
* **Insert Data**
```bash
sqlite3 mydb.sqlite <<'EOF'
INSERT INTO users (name, age) VALUES
('Alice', 30),
('Bob', 25);
EOF
```
* **Query Data**
```bash
sqlite3 -header -column mydb.sqlite <<'EOF'
SELECT * FROM users;
EOF
```
* **Edit Structure (ALTER)**
```bash
sqlite3 mydb.sqlite <<'EOF'
ALTER TABLE users ADD COLUMN email TEXT;
EOF
```
* **Update Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
UPDATE users SET age = 31 WHERE name = 'Alice';
EOF
```
* **Delete Rows**
```bash
sqlite3 mydb.sqlite <<'EOF'
DELETE FROM users WHERE name = 'Bob';
EOF
```
-----
⌜NPL@1.0⌝
# Noizu Prompt Lingua (NPL)
A modular, structured framework for advanced prompt engineering and agent simulation with context-aware loading capabilities.
**Convention**: Additional details and deep-dive instructions are available under `${NPL_HOME}/npl/` and can be loaded on an as-needed basis.
## Core Concepts
**npl-declaration**
: Framework version and rule boundaries that establish operational context and constraints. See `${NPL_HOME}/npl/declarations.md`
**agent**
: Simulated entity with defined behaviors, capabilities, and response patterns for specific roles or functions. See `${NPL_HOME}/npl/agent.md`
**intuition-pump**
: Structured reasoning and thinking techniques that guide problem-solving and response construction. See `${NPL_HOME}/npl/planning.md`
**syntax-element**
: Foundational formatting conventions and placeholder systems for prompt construction. See `${NPL_HOME}/npl/syntax.md`
**directive**
: Specialized instruction patterns for precise agent behavior modification and output control. See `${NPL_HOME}/npl/directive.md`
**prompt-prefix**
: Response mode indicators that shape how output is generated under specific purposes or processing contexts. See `${NPL_HOME}/npl/prefix.md`
## Essential Syntax
**highlight**
: `` `term` `` - Emphasize key concepts
**attention**
: `🎯 critical instruction` - Mark high-priority directives
**placeholder**
: `<term>`, `{term}`, `<<qualifier>:term>` - Expected input/output locations
**in-fill**
: `[...]` - Like in-paint but for text, indicates section where generated content should be provided
**note**
: `(note:[...])` - Prompt notes/comments describing purpose/layout but not directly resulting in output
**infer**
: `...`, `etc.` - Assume or generate additional entries based on context (e.g., animals: birds, cats, ... → dogs, horses, zebras, ants, echinoderms)
**qualifier**
: `term|qualifier` - Can be used with most syntax elements. Example: `[...|continue with 5 more examples]`
**fences**
: Special code sections with type indicators. Common types: `example`, `syntax`, `format`, `note`, `diagram`. See `./npl/fences.md`
**omission**
: `[___]` - Content left out for brevity that is expected in actual input/output
### See Also
- `${NPL_HOME}/npl/syntax.md` and `${NPL_HOME}/npl/syntax/*` for complete syntax reference and detailed specifications
## Instructing Patterns
Specialized syntax for directing agent behavior and response construction through structured commands and templates.
**handlebars**
: Template-like control structures (`{{if}}`, `{{foreach}}`). If format issues arise, load `${NPL_HOME}/npl/instructing/handlebars.md`
**alg-speak**
: `alg`, `alg-pseudo`, `alg-*` fences for algorithm specification. If unclear, load `${NPL_HOME}/npl/instructing/alg.md`
**mermaid**
: Diagram-based instruction flow using flowchart, stateDiagram, sequenceDiagram
**annotation**
: Used for iterative refinement of code changes, UX modifications, and design interactions. Load `${NPL_HOME}/npl/instructing/annotation.md` if needed
## Response Formatting
Prompts often provide input/output shape and example instructions with tags and fences like `input-syntax`, `output-syntax`, `syntax`, `input-example`, `output-example`, `example`, `examples`. If present, load `${NPL_HOME}/npl/formatting.md` and format-specific fence under `${NPL_HOME}/npl/fences/<name>.md`
```output-format
Hello <user.name>,
Did you know [...|funny factoid].
Have a great day!
```
**template**
: Reusable templates, commonly handlebar style. Defined using template fences with handlebar syntax. See `${NPL_HOME}/npl/formatting/template.md`
**artifact**
: NPL-artifacts structure output and request artifact output of SVG, code, and other types with special encoding and metadata syntax. See `${NPL_HOME}/npl/fences/artifact.md`
### See Also
- Reusable templates for consistent output patterns - load `${NPL_HOME}/npl/formatting/template.md` if prompt uses template syntax
## Special Sections
Special prompt sections such as NPL/agent/tool declarations, runtime flags, and restricted/highest-precedence instruction blocks may be included. Load appropriate instruction files for context.
**xpl**
: This document itself - framework version and rule boundaries
**npl-extension**
: `⌜extend:NPL@version⌝[...modifications...]⌞extend:NPL@version⌟` - An extension or modification of NPL conventions. See `${NPL_HOME}/npl/special-sections/npl-extension.md`
**agent**
: `⌜agent-name|type|NPL@version⌝[...definition...]⌞agent-name⌟` - Used to define agent behavior, capabilities, and response patterns. See `${NPL_HOME}/npl/special-sections/agent.md`
**runtime-flags**
: `⌜🏳️[...]⌟` - Behavior modification settings within flags fence. See `${NPL_HOME}/npl/special-sections/runtime-flags.md`
**secure-prompt**
: `⌜🔒[...]⌟` - Highest-precedence instruction blocks that cannot be overridden. See `${NPL_HOME}/npl/special-sections/secure-prompt.md`
**named-template**
: `⌜🧱 template-name⌝[...template definition...]⌞🧱 template-name⌟` - Define reusable named templates for consistent output patterns. See `${NPL_HOME}/npl/special-sections/named-template.md`
## Prompt Prefixes
Response mode indicators using `emoji➤` pattern to shape output generation under specific processing contexts. Directive-specific details may be present under `${NPL_HOME}/npl/prefix/<emoji>.md`
**word-riddle**
: `🗣️❓➤` - Word puzzle or riddle format
Example: `🗣️❓➤ Nothing in the dictionary starts with an n and ends in a g`
If directive syntax detected, scan `${NPL_HOME}/npl/prefix.md` and `${NPL_HOME}/npl/prefix/*` for details.
## Directives
Specialized extension widgets/tags for precise formatting and behavior control, such as tabular output requirements. Directive-specific details may be present under `./npl/directive/<emoji>.md`
**table-directive**
: `⟪📅: (column alignments and labels) | content description⟫` - Structured table formatting with specified alignments and headers
If pattern `⟪<prefix(s)>:...⟫` seen, scan `${NPL_HOME}/npl/directive.md`
## Planning & Intuition Pumps
Prompts may instruct agents to generate or apply special planning and thinking patterns, commonly listed as sections to include in output via formal syntax/format blocks or simple instructions. Implemented as either XHTML tags or named fences.
**Types**: `npl-intent`, `npl-cot`, `npl-reflection`, `npl-tangent`, `npl-panel`, `npl-panel-*`, `npl-critique`, `npl-rubric`
Blocks like `npl-<type>` are generally documented under `${NPL_HOME}/npl/pumps/<type>.md`
⌞NPL@1.0⌟
Write Preview
Loading…
Cancel
Save