Fundamental Building Blocks

```bash task-name --descr "Description of the task"
echo "This is a code cell"
` ` `

```language identity --flags { json5-attributes }
code content
```

```bash task-name --flag value { "attr": "value" } --descr "Description of the task"
#!/usr/bin/env bash
echo "cell content"
` ` `

┌─ Language identifier (required)
│       ┌─ Identity (optional, unique name)
│       │         ┌─ Flags (optional, command-line style options)
│       │         │              ┌─ Attributes (optional, JSON5)
│       │         │              │
bash task-name --flag value { "attr": "value" }

```bash greet
echo "Hello, World!"
```

```bash greet --descr "Display a greeting message"
echo "Hello, World!"
```

```bash process-data --dep fetch-data --descr "Process the fetched data"
python process.py data.json
```

```bash build --dep test --descr "Build the project" --capture ./build.log
npm run build
```

```bash long-task --descr "Task with timeout" { timeout: 300, retry: 3 }
./long-running-script.sh
```

interface CodeCell {
  startLine: number  // Where cell begins (including fence)
  endLine: number    // Where cell ends (including closing fence)
  source: string     // The actual code content
}

```bash my-unique-name
echo "I can be referenced as 'my-unique-name'"
```

```bash
# This cell has no identity
# It won't appear in task lists
echo "Anonymous cell"
```

```bash greet --descr "Say hello"
echo "Hello, World!"
` ` `

Define Task → Parse Metadata → Build Dependencies → Execute → Capture Output

```bash build --capture output.txt --dep compile
npm run build > output.txt
` ` `

interface TaskDirective {
  nature: "TASK" | "CONTENT"   // Execution vs generation
  identity: string              // Unique name
  language: LanguageSpec        // How to execute
  deps?: string[]               // Dependencies
}

```bash deploy --dep build --dep test
kubectl apply -f deployment.yml
` ` `

{
  nature: "TASK",
  identity: "deploy",
  language: { name: "bash", ... },
  deps: ["build", "test"]
}

language [identity] [flags...] [attributes]

```bash task-name --long-flag value -s --bool-flag { "json": "attrs" }
content
` ` `

```bash setup --descr "Initialize the development environment"
npm install
```

```bash deploy --dep build --dep test
kubectl apply -f deployment.yaml
```

```bash get-version --capture version.txt
git describe --tags
```

```bash greet -I
echo "Hello, ${NAME}!"
```

```sql create-table --injectable
CREATE TABLE users (id INT PRIMARY KEY);
```

```bash deploy-step -G deploy
kubectl apply -f manifests/
```

```language identity --flags { "key": "value", nested: { obj: true } }
content
` ` `

```sql page.sql {
  route: {
    caption: "Home Page",
    description: "Main landing page"
  },
  cache: true,
  ttl: 3600,
  // Comments allowed
  'single-quotes': 'work',
  trailingComma: 'ok',
}
SELECT * FROM pages;
` ` `

---
title: My Spryfile
version: 1.0
sqlpage-conf:
  database_url: sqlite://data.db
  port: 9227
custom:
  - value1
  - value2
---

# Document starts here

Content...

```bash deploy -I
echo "Deploying ${fm.app.name} to ${fm.app.environment}"
` ` `

interface MyFrontmatter {
  app: {
    name: string
    environment: string
  }
}

const notebook: Notebook<string, MyFrontmatter> = /* ... */
console.log(notebook.fm.app.name)

```bash compile
gcc main.c -o main
` ` `

```bash test --dep compile
./main --test
` ` `

```bash deploy --dep test
scp main server:/app/
` ` `

compile → test → deploy

```bash lint --descr "Lint the code"
eslint src/
` ` `

```bash typecheck --descr "Type check the code"
tsc --noEmit
` ` `

```bash build --dep lint --dep typecheck --descr "Build the project"
npm run build
` ` `

lint ───────┐
            ├──→ build
typecheck ──┘

```bash a --descr "Task A"
echo "A"
` ` `

```bash b --dep a --descr "Task B"
echo "B"
` ` `

```bash c --dep a --descr "Task C"
echo "C"
` ` `

```bash d --dep b --dep c --descr "Task D"
echo "D"
` ` `

Step 1: a          (no deps)
Step 2: b, c       (only depend on a, can run in parallel)
Step 3: d          (depends on b and c)

```bash task-a --dep task-b --descr "Task A"
echo "A"
` ` `

```bash task-b --dep task-a --descr "Task B"
echo "B"
` ` `

```bash build
npm run build
` ` `

```bash test --dep build --descr "Run tests"
npm test
` ` `

```bash clean --graph maintenance --descr "Clean build artifacts"
rm -rf dist/
` ` `

```bash reset --graph maintenance --dep clean --descr "Reset environment"
git clean -fdx
` ` `

spry rb run file.md              # Runs main graph
spry rb run file.md --graph maintenance  # Runs maintenance graph

```sql PARTIAL header.sql
SELECT 'shell' AS component, 'My App' AS title;
` ` `

```sql page.sql -I
${await partial("header.sql")}
SELECT 'list' AS component;
SELECT * FROM users;
` ` `

SELECT 'shell' AS component, 'My App' AS title;
SELECT 'list' AS component;
SELECT * FROM users;

```sql PARTIAL layout.sql --inject **/*.sql
SELECT 'shell' AS component, 'App' AS title;
` ` `

```sql index.sql
SELECT 'Welcome' AS message;
` ` `

```sql about.sql
SELECT 'About' AS message;
` ` `

SELECT 'shell' AS component, 'App' AS title;
SELECT 'Welcome' AS message;

```bash deploy -I --descr "Deploy the app"
echo "Deploying version ${env.APP_VERSION}"
` ` `

```bash greet -I --descr "Greet user"
echo "Hello, ${env.USER || 'World'}!"
echo "Date: ${new Date().toISOString()}"
` ` `

Raw Markdown
    ↓ Parse
MDAST (Abstract Syntax Tree)
    ↓ Extract
Notebook (cells + frontmatter)
    ↓ Section
Playbook (sections + context)
    ↓ Analyze
TaskDirectives (executable)

interface Notebook<Provenance, Frontmatter, CellAttrs> {
  provenance: Provenance       // File path or identifier
  fm: Frontmatter              // Parsed frontmatter
  cells: NotebookCodeCell[]    // All code cells
  issues: Issue[]              // Parsing warnings/errors
}

interface Playbook<Provenance, Frontmatter, CellAttrs> {
  notebook: Notebook<...>      // Underlying notebook
  sections: Section[]          // Document sections
  cells: PlaybookCodeCell[]    // Cells with section context
}