Prompt file imported from SiriusScan/app-agent (.cursor/commands/project-intro.md). Copyright stays with the author.

Sirius Agent - Template-Based Vulnerability Detection System

Name: project-intro
Author: SiriusScan

Developer Onboarding Guide

Welcome to the Sirius Agent project! This document will get you up to speed quickly.

What is This?

Sirius Agent is a cross-platform vulnerability detection agent that uses YAML-based templates to identify security vulnerabilities on host systems. Think of it as "Nuclei for host-side vulnerability detection" rather than network scanning.

Key Concepts:

Templates (YAML files) define what to look for
Modules (Go code) perform the actual detection
Agent executes templates and reports results
Worker Pool runs thousands of templates in parallel

Quick Start

Prerequisites:

Go 1.24+ installed
Docker installed (for Linux testing)
Basic understanding of YAML and Go

Get Running in 5 Minutes:

# 1. Clone and navigate
cd app-agent

# 2. Build the agent
GOOS=linux GOARCH=amd64 go build -o bin/agent cmd/agent/main.go

# 3. Run a test template (in Linux container)
cd testing
make build-linux
make quick

# You should see JSON output with detection results

Project Architecture

High-Level Flow:

Templates (YAML)
    ↓
Agent parses templates
    ↓
Worker pool (parallel execution)
    ↓
Each template → Sequential detection steps
    ↓
Modules execute (FileHash, FileContent, etc.)
    ↓
Results (JSON/JSONL output)

Directory Structure:

app-agent/
├── cmd/agent/                  # Main entry point
├── internal/
│   ├── modules/                # Detection modules
│   │   ├── registry/           # Module registration system
│   │   ├── filehash/           # Hash-based detection
│   │   ├── filecontent/        # Content/regex detection
│   │   └── versioncmd/         # Command version detection
│   ├── common/                 # Shared libraries
│   │   ├── files/              # File operations
│   │   ├── os/                 # OS detection
│   │   ├── patterns/           # Regex matching
│   │   └── results/            # Result builders
│   ├── template/               # Template parsing & execution
│   └── commands/               # CLI commands (Cobra)
├── testing/                    # Container-based testing
│   ├── test-data/              # Fake vulnerable files
│   └── test-templates/         # Test templates
└── templates/                  # Example templates

Core Components

1. Templates (YAML)

Templates define WHAT to detect:

id: openssh-cve-2024-1117
info:
  name: OpenSSH 6.5.1 RCE
  severity: critical
  description: Detects vulnerable OpenSSH version

detection:
  logic: all # AND logic (all steps must match)
  steps:
    - type: file_hash
      path: /usr/sbin/sshd
      hash: "4f5f9..."
      weight: 0.8

    - type: file_content
      path: /usr/sbin/sshd
      regex: "OpenSSH_6\\.5\\.1"
      weight: 0.3

2. Modules (Go)

Modules define HOW to detect:

// FileHashModule calculates and compares file hashes
type FileHashModule struct{}

func (m *FileHashModule) Execute(ctx context.Context, config StepConfig) (*Result, error) {
    // Extract config
    path := config.GetString("path")
    expectedHash := config.GetString("hash")

    // Calculate hash using shared library
    actualHash, err := files.CalculateHash(path, "sha256")

    // Build and return result
    return results.Build(matched, confidence, evidence), nil
}

3. CLI Commands (Cobra)

User interface for the agent:

# Standalone mode - run templates
./agent template run /path/to/template.yaml
./agent template run-all /templates/

# Introspection
./agent module list
./agent module info file_hash

# Server mode (connects to gRPC server)
./agent server

Development Workflow

1. Working on macOS, Targeting Linux

# Edit code on macOS (your IDE)
vim internal/modules/filehash/filehash.go

# Cross-compile for Linux
cd testing
make build-linux

# Run in Linux container
make quick

# See results immediately

2. Adding a New Module

// 1. Create module directory
internal/modules/mymodule/mymodule.go

// 2. Implement Module interface
type MyModule struct{}

func (m *MyModule) Execute(ctx context.Context, config StepConfig) (*Result, error) {
    // Your detection logic here
    return result, nil
}

// 3. Register in init()
func init() {
    modules.Register(&MyModule{}, modules.Descriptor{
        Type:        "my_module",
        Name:        "My Module",
        Description: "What this module does",
        SupportedOS: []string{"linux", "darwin"},
    })
}

3. Testing Your Module

# Create test template
# testing/test-templates/test-my-module.yaml
id: test-my-module
info:
  name: Test My Module
  severity: info

detection:
  steps:
    - type: my_module
      # your config fields

# Run the test
cd testing
make build-linux
make test-template TEMPLATE=test-my-module.yaml

Key Design Principles

1. MVP Focus

Simple AND/OR logic (no complex expressions)
Four core modules (FileHash, FileContent, VersionCmd, [Script deferred])
Linux-first (macOS/Windows later)
Outcome-focused testing (not coverage metrics)

2. Modularity

Each module is self-contained
Modules use shared libraries (DRY principle)
No module-to-module dependencies
Easy to add new modules

3. Scalability

Worker pool for parallel template execution
Sequential steps within templates
10,000+ templates should complete in ~20 minutes

4. Developer Experience

Fast iteration (no container rebuilds)
Clear error messages
Simple testing workflow
Good documentation

Common Tasks

Run a Single Template:

./agent template run /path/to/template.yaml

Run All Templates in Directory:

./agent template run-all /templates/
# Outputs JSONL (one JSON object per line)

List Registered Modules:

./agent module list

Get Module Details:

./agent module info file_hash
# Shows: description, supported OS, config fields

Validate Template Syntax:

./agent template validate /path/to/template.yaml

Testing Philosophy

We focus on integration testing (does it work end-to-end?) rather than unit testing (does each function work?).

Test Pattern:

Create fake vulnerable file in testing/test-data/
Write template that should detect it
Run template in Linux container
Check JSON output - did it detect correctly?
If not, debug, fix, repeat

No complex test frameworks. Just run it and see if it works.

Documentation Structure

For Users:

README.md - Project overview
documentation/agent_template_system_PRD.md - Product requirements
Template writing guides (TBD)

For Developers:

project/PROJECT-INTRO.md - This file (onboarding)
project/BRAINSTORM.template-system-notes.md - Design decisions
project/PLAN.agent-template-system-implementation.md - Implementation plan
Module-specific READMEs in each module directory

FAQ

Q: Why templates instead of code? A: Security engineers can write templates without knowing Go. Templates are portable, shareable, and version-controlled separately from the agent.

Q: Why not just use Nuclei? A: Nuclei is for network scanning. We need host-side detection (file hashes, installed packages, running services, etc.)

Q: Why Go? A: Cross-platform, fast, good concurrency, single binary distribution, widely used in security tools.

Q: Why Linux-first? A: Most servers run Linux. Get it working there first, then expand to macOS/Windows.

Q: Where's the Script module? A: Deferred to post-MVP. Will use embedded Lua for true cross-platform scripting.

Q: How do I add a new detection type? A: Create a new module implementing the Module interface, register it in init(), document its config fields.

Q: Where do templates come from? A: Security team writes them, community contributes them, they're version-controlled in a template repository (separate from agent code).

Getting Help

Read the brainstorming notes: project/BRAINSTORM.template-system-notes.md
Check the implementation plan: project/PLAN.agent-template-system-implementation.md
Look at existing modules: internal/modules/*/ for examples
Ask questions: Tag @security-team in your questions

Next Steps

Read the Implementation Plan
Review Brainstorming Notes for design rationale
Set up your development environment (Docker, Go)
Pick a task from tasks/template-system-mvp.json
Start coding!

Welcome to the team! Let's build something great. 🚀

# Sirius Agent - Template-Based Vulnerability Detection System ## Developer Onboarding Guide Welcome to the Sirius Agent project! This document will get you up to speed quickly. --- ## What is This? **Sirius Agent** is a cross-platform vulnerability detection agent that uses YAML-based templates to identify security vulnerabilities on host systems. Think of it as "Nuclei for host-side vulnerability detection" rather than network scanning. ### Key Concepts: 1. **Templates** (YAML files) define what to look for 2. **Modules** (Go code) perform the actual detection 3. **Agent** executes templates and reports results 4. **Worker Pool** runs thousands of templates in parallel --- ## Quick Start ### Prerequisites: - Go 1.24+ installed - Docker installed (for Linux testing) - Basic understanding of YAML and Go ### Get Running in 5 Minutes: ```bash # 1. Clone and navigate cd app-agent # 2. Build the agent GOOS=linux GOARCH=amd64 go build -o bin/agent cmd/agent/main.go # 3. Run a test template (in Linux container) cd testing make build-linux make quick # You should see JSON output with detection results ``` --- ## Project Architecture ### High-Level Flow: ``` Templates (YAML) ↓ Agent parses templates ↓ Worker pool (parallel execution) ↓ Each template → Sequential detection steps ↓ Modules execute (FileHash, FileContent, etc.) ↓ Results (JSON/JSONL output) ``` ### Directory Structure: ``` app-agent/ ├── cmd/agent/ # Main entry point ├── internal/ │ ├── modules/ # Detection modules │ │ ├── registry/ # Module registration system │ │ ├── filehash/ # Hash-based detection │ │ ├── filecontent/ # Content/regex detection │ │ └── versioncmd/ # Command version detection │ ├── common/ # Shared libraries │ │ ├── files/ # File operations │ │ ├── os/ # OS detection │ │ ├── patterns/ # Regex matching │ │ └── results/ # Result builders │ ├── template/ # Template parsing & execution │ └── commands/ # CLI commands (Cobra) ├── testing/ # Container-based testing │ ├── test-data/ # Fake vulnerable files │ └── test-templates/ # Test templates └── templates/ # Example templates ``` --- ## Core Components ### 1. Templates (YAML) Templates define WHAT to detect: ```yaml id: openssh-cve-2024-1117 info: name: OpenSSH 6.5.1 RCE severity: critical description: Detects vulnerable OpenSSH version detection: logic: all # AND logic (all steps must match) steps: - type: file_hash path: /usr/sbin/sshd hash: "4f5f9..." weight: 0.8 - type: file_content path: /usr/sbin/sshd regex: "OpenSSH_6\\.5\\.1" weight: 0.3 ``` ### 2. Modules (Go) Modules define HOW to detect: ```go // FileHashModule calculates and compares file hashes type FileHashModule struct{} func (m *FileHashModule) Execute(ctx context.Context, config StepConfig) (*Result, error) { // Extract config path := config.GetString("path") expectedHash := config.GetString("hash") // Calculate hash using shared library actualHash, err := files.CalculateHash(path, "sha256") // Build and return result return results.Build(matched, confidence, evidence), nil } ``` ### 3. CLI Commands (Cobra) User interface for the agent: ```bash # Standalone mode - run templates ./agent template run /path/to/template.yaml ./agent template run-all /templates/ # Introspection ./agent module list ./agent module info file_hash # Server mode (connects to gRPC server) ./agent server ``` --- ## Development Workflow ### 1. Working on macOS, Targeting Linux ```bash # Edit code on macOS (your IDE) vim internal/modules/filehash/filehash.go # Cross-compile for Linux cd testing make build-linux # Run in Linux container make quick # See results immediately ``` ### 2. Adding a New Module ```go // 1. Create module directory internal/modules/mymodule/mymodule.go // 2. Implement Module interface type MyModule struct{} func (m *MyModule) Execute(ctx context.Context, config StepConfig) (*Result, error) { // Your detection logic here return result, nil } // 3. Register in init() func init() { modules.Register(&MyModule{}, modules.Descriptor{ Type: "my_module", Name: "My Module", Description: "What this module does", SupportedOS: []string{"linux", "darwin"}, }) } ``` ### 3. Testing Your Module ```yaml # Create test template # testing/test-templates/test-my-module.yaml id: test-my-module info: name: Test My Module severity: info detection: steps: - type: my_module # your config fields ``` ```bash # Run the test cd testing make build-linux make test-template TEMPLATE=test-my-module.yaml ``` --- ## Key Design Principles ### 1. **MVP Focus** - Simple AND/OR logic (no complex expressions) - Four core modules (FileHash, FileContent, VersionCmd, [Script deferred]) - Linux-first (macOS/Windows later) - Outcome-focused testing (not coverage metrics) ### 2. **Modularity** - Each module is self-contained - Modules use shared libraries (DRY principle) - No module-to-module dependencies - Easy to add new modules ### 3. **Scalability** - Worker pool for parallel template execution - Sequential steps within templates - 10,000+ templates should complete in ~20 minutes ### 4. **Developer Experience** - Fast iteration (no container rebuilds) - Clear error messages - Simple testing workflow - Good documentation --- ## Common Tasks ### Run a Single Template: ```bash ./agent template run /path/to/template.yaml ``` ### Run All Templates in Directory: ```bash ./agent template run-all /templates/ # Outputs JSONL (one JSON object per line) ``` ### List Registered Modules: ```bash ./agent module list ``` ### Get Module Details: ```bash ./agent module info file_hash # Shows: description, supported OS, config fields ``` ### Validate Template Syntax: ```bash ./agent template validate /path/to/template.yaml ``` --- ## Testing Philosophy We focus on **integration testing** (does it work end-to-end?) rather than unit testing (does each function work?). ### Test Pattern: 1. Create fake vulnerable file in `testing/test-data/` 2. Write template that should detect it 3. Run template in Linux container 4. Check JSON output - did it detect correctly? 5. If not, debug, fix, repeat **No complex test frameworks. Just run it and see if it works.** --- ## Documentation Structure ### For Users: - `README.md` - Project overview - `documentation/agent_template_system_PRD.md` - Product requirements - Template writing guides (TBD) ### For Developers: - `project/PROJECT-INTRO.md` - This file (onboarding) - `project/BRAINSTORM.template-system-notes.md` - Design decisions - `project/PLAN.agent-template-system-implementation.md` - Implementation plan - Module-specific READMEs in each module directory --- ## FAQ **Q: Why templates instead of code?** A: Security engineers can write templates without knowing Go. Templates are portable, shareable, and version-controlled separately from the agent. **Q: Why not just use Nuclei?** A: Nuclei is for network scanning. We need host-side detection (file hashes, installed packages, running services, etc.) **Q: Why Go?** A: Cross-platform, fast, good concurrency, single binary distribution, widely used in security tools. **Q: Why Linux-first?** A: Most servers run Linux. Get it working there first, then expand to macOS/Windows. **Q: Where's the Script module?** A: Deferred to post-MVP. Will use embedded Lua for true cross-platform scripting. **Q: How do I add a new detection type?** A: Create a new module implementing the Module interface, register it in init(), document its config fields. **Q: Where do templates come from?** A: Security team writes them, community contributes them, they're version-controlled in a template repository (separate from agent code). --- ## Getting Help 1. **Read the brainstorming notes**: `project/BRAINSTORM.template-system-notes.md` 2. **Check the implementation plan**: `project/PLAN.agent-template-system-implementation.md` 3. **Look at existing modules**: `internal/modules/*/` for examples 4. **Ask questions**: Tag @security-team in your questions --- ## Next Steps 1. Read the [Implementation Plan](../project/PLAN.agent-template-system-implementation.md) 2. Review [Brainstorming Notes](../project/BRAINSTORM.template-system-notes.md) for design rationale 3. Set up your development environment (Docker, Go) 4. Pick a task from `tasks/template-system-mvp.json` 5. Start coding! --- **Welcome to the team! Let's build something great.** 🚀

{ "prompt": "# Sirius Agent - Template-Based Vulnerability Detection System\n\n## Developer Onboarding Guide\n\nWelcome to the Sirius Agent project! This document will get you up to speed quickly.\n\n---\n\n## What is This?\n\n**Sirius Agent** is a cross-platform vulnerability detection agent that uses YAML-based templates to identify security vulnerabilities on host systems. Think of it as \"Nuclei for host-side vulnerability detection\" rather than network scanning.\n\n### Key Concepts:\n\n1. **Templates** (YAML files) define what to look for\n2. **Modules** (Go code) perform the actual detection\n3. **Agent** executes templates and reports results\n4. **Worker Pool** runs thousands of templates in parallel\n\n---\n\n## Quick Start\n\n### Prerequisites:\n\n- Go 1.24+ installed\n- Docker installed (for Linux testing)\n- Basic understanding of YAML and Go\n\n### Get Running in 5 Minutes:\n\n```bash\n# 1. Clone and navigate\ncd app-agent\n\n# 2. Build the agent\nGOOS=linux GOARCH=amd64 go build -o bin/agent cmd/agent/main.go\n\n# 3. Run a test template (in Linux container)\ncd testing\nmake build-linux\nmake quick\n\n# You should see JSON output with detection results\n```\n\n---\n\n## Project Architecture\n\n### High-Level Flow:\n\n```\nTemplates (YAML)\n ↓\nAgent parses templates\n ↓\nWorker pool (parallel execution)\n ↓\nEach template → Sequential detection steps\n ↓\nModules execute (FileHash, FileContent, etc.)\n ↓\nResults (JSON/JSONL output)\n```\n\n### Directory Structure:\n\n```\napp-agent/\n├── cmd/agent/ # Main entry point\n├── internal/\n│ ├── modules/ # Detection modules\n│ │ ├── registry/ # Module registration system\n│ │ ├── filehash/ # Hash-based detection\n│ │ ├── filecontent/ # Content/regex detection\n│ │ └── versioncmd/ # Command version detection\n│ ├── common/ # Shared libraries\n│ │ ├── files/ # File operations\n│ │ ├── os/ # OS detection\n│ │ ├── patterns/ # Regex matching\n│ │ └── results/ # Result builders\n│ ├── template/ # Template parsing & execution\n│ └── commands/ # CLI commands (Cobra)\n├── testing/ # Container-based testing\n│ ├── test-data/ # Fake vulnerable files\n│ └── test-templates/ # Test templates\n└── templates/ # Example templates\n```\n\n---\n\n## Core Components\n\n### 1. Templates (YAML)\n\nTemplates define WHAT to detect:\n\n```yaml\nid: openssh-cve-2024-1117\ninfo:\n name: OpenSSH 6.5.1 RCE\n severity: critical\n description: Detects vulnerable OpenSSH version\n\ndetection:\n logic: all # AND logic (all steps must match)\n steps:\n - type: file_hash\n path: /usr/sbin/sshd\n hash: \"4f5f9...\"\n weight: 0.8\n\n - type: file_content\n path: /usr/sbin/sshd\n regex: \"OpenSSH_6\\\\.5\\\\.1\"\n weight: 0.3\n```\n\n### 2. Modules (Go)\n\nModules define HOW to detect:\n\n```go\n// FileHashModule calculates and compares file hashes\ntype FileHashModule struct{}\n\nfunc (m *FileHashModule) Execute(ctx context.Context, config StepConfig) (*Result, error) {\n // Extract config\n path := config.GetString(\"path\")\n expectedHash := config.GetString(\"hash\")\n\n // Calculate hash using shared library\n actualHash, err := files.CalculateHash(path, \"sha256\")\n\n // Build and return result\n return results.Build(matched, confidence, evidence), nil\n}\n```\n\n### 3. CLI Commands (Cobra)\n\nUser interface for the agent:\n\n```bash\n# Standalone mode - run templates\n./agent template run /path/to/template.yaml\n./agent template run-all /templates/\n\n# Introspection\n./agent module list\n./agent module info file_hash\n\n# Server mode (connects to gRPC server)\n./agent server\n```\n\n---\n\n## Development Workflow\n\n### 1. Working on macOS, Targeting Linux\n\n```bash\n# Edit code on macOS (your IDE)\nvim internal/modules/filehash/filehash.go\n\n# Cross-compile for Linux\ncd testing\nmake build-linux\n\n# Run in Linux container\nmake quick\n\n# See results immediately\n```\n\n### 2. Adding a New Module\n\n```go\n// 1. Create module directory\ninternal/modules/mymodule/mymodule.go\n\n// 2. Implement Module interface\ntype MyModule struct{}\n\nfunc (m *MyModule) Execute(ctx context.Context, config StepConfig) (*Result, error) {\n // Your detection logic here\n return result, nil\n}\n\n// 3. Register in init()\nfunc init() {\n modules.Register(&MyModule{}, modules.Descriptor{\n Type: \"my_module\",\n Name: \"My Module\",\n Description: \"What this module does\",\n SupportedOS: []string{\"linux\", \"darwin\"},\n })\n}\n```\n\n### 3. Testing Your Module\n\n```yaml\n# Create test template\n# testing/test-templates/test-my-module.yaml\nid: test-my-module\ninfo:\n name: Test My Module\n severity: info\n\ndetection:\n steps:\n - type: my_module\n # your config fields\n```\n\n```bash\n# Run the test\ncd testing\nmake build-linux\nmake test-template TEMPLATE=test-my-module.yaml\n```\n\n---\n\n## Key Design Principles\n\n### 1. **MVP Focus**\n\n- Simple AND/OR logic (no complex expressions)\n- Four core modules (FileHash, FileContent, VersionCmd, [Script deferred])\n- Linux-first (macOS/Windows later)\n- Outcome-focused testing (not coverage metrics)\n\n### 2. **Modularity**\n\n- Each module is self-contained\n- Modules use shared libraries (DRY principle)\n- No module-to-module dependencies\n- Easy to add new modules\n\n### 3. **Scalability**\n\n- Worker pool for parallel template execution\n- Sequential steps within templates\n- 10,000+ templates should complete in ~20 minutes\n\n### 4. **Developer Experience**\n\n- Fast iteration (no container rebuilds)\n- Clear error messages\n- Simple testing workflow\n- Good documentation\n\n---\n\n## Common Tasks\n\n### Run a Single Template:\n\n```bash\n./agent template run /path/to/template.yaml\n```\n\n### Run All Templates in Directory:\n\n```bash\n./agent template run-all /templates/\n# Outputs JSONL (one JSON object per line)\n```\n\n### List Registered Modules:\n\n```bash\n./agent module list\n```\n\n### Get Module Details:\n\n```bash\n./agent module info file_hash\n# Shows: description, supported OS, config fields\n```\n\n### Validate Template Syntax:\n\n```bash\n./agent template validate /path/to/template.yaml\n```\n\n---\n\n## Testing Philosophy\n\nWe focus on **integration testing** (does it work end-to-end?) rather than unit testing (does each function work?).\n\n### Test Pattern:\n\n1. Create fake vulnerable file in `testing/test-data/`\n2. Write template that should detect it\n3. Run template in Linux container\n4. Check JSON output - did it detect correctly?\n5. If not, debug, fix, repeat\n\n**No complex test frameworks. Just run it and see if it works.**\n\n---\n\n## Documentation Structure\n\n### For Users:\n\n- `README.md` - Project overview\n- `documentation/agent_template_system_PRD.md` - Product requirements\n- Template writing guides (TBD)\n\n### For Developers:\n\n- `project/PROJECT-INTRO.md` - This file (onboarding)\n- `project/BRAINSTORM.template-system-notes.md` - Design decisions\n- `project/PLAN.agent-template-system-implementation.md` - Implementation plan\n- Module-specific READMEs in each module directory\n\n---\n\n## FAQ\n\n**Q: Why templates instead of code?**\nA: Security engineers can write templates without knowing Go. Templates are portable, shareable, and version-controlled separately from the agent.\n\n**Q: Why not just use Nuclei?**\nA: Nuclei is for network scanning. We need host-side detection (file hashes, installed packages, running services, etc.)\n\n**Q: Why Go?**\nA: Cross-platform, fast, good concurrency, single binary distribution, widely used in security tools.\n\n**Q: Why Linux-first?**\nA: Most servers run Linux. Get it working there first, then expand to macOS/Windows.\n\n**Q: Where's the Script module?**\nA: Deferred to post-MVP. Will use embedded Lua for true cross-platform scripting.\n\n**Q: How do I add a new detection type?**\nA: Create a new module implementing the Module interface, register it in init(), document its config fields.\n\n**Q: Where do templates come from?**\nA: Security team writes them, community contributes them, they're version-controlled in a template repository (separate from agent code).\n\n---\n\n## Getting Help\n\n1. **Read the brainstorming notes**: `project/BRAINSTORM.template-system-notes.md`\n2. **Check the implementation plan**: `project/PLAN.agent-template-system-implementation.md`\n3. **Look at existing modules**: `internal/modules/*/` for examples\n4. **Ask questions**: Tag @security-team in your questions\n\n---\n\n## Next Steps\n\n1. Read the [Implementation Plan](../project/PLAN.agent-template-system-implementation.md)\n2. Review [Brainstorming Notes](../project/BRAINSTORM.template-system-notes.md) for design rationale\n3. Set up your development environment (Docker, Go)\n4. Pick a task from `tasks/template-system-mvp.json`\n5. Start coding!\n\n---\n\n**Welcome to the team! Let's build something great.** 🚀", "variables": [], "notes": "Welcome to the Sirius Agent project! This document will get you up to speed quickly.", "metadata": { "source": { "provider": "github-cursor-commands", "repository": "https://github.com/SiriusScan/app-agent", "path": ".cursor/commands/project-intro.md", "ref": "9311f3805db9cc08740f1b588b6f3bff9191c9dd", "url": "https://github.com/SiriusScan/app-agent/blob/9311f3805db9cc08740f1b588b6f3bff9191c9dd/.cursor/commands/project-intro.md", "key": "SiriusScan/app-agent/.cursor/commands/project-intro.md" } } }

About