Fundamental Building Blocks

```bash task-name
echo "This is a cell"
` ` `

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

┌─ Language identifier (required)
│       ┌─ Task identity (optional, first bare token)
│       │         ┌─ Processing Instructions (optional, flags)
│       │         │              ┌─ Attributes (optional, JSON5)
│       │         │              │
bash task-name --flag value { "attr": "value" }

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

```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
` ` `

```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
eslint src/
` ` `

```bash typecheck
tsc --noEmit
` ` `

```bash build --dep lint --dep typecheck
npm run build
` ` `

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

```bash a
echo "A"
` ` `

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

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

```bash d --dep b --dep c
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
echo "A"
` ` `

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

```bash build
npm run build
` ` `

```bash test --dep build
npm test
` ` `

```bash clean --graph maintenance
rm -rf dist/
` ` `

```bash reset --graph maintenance --dep clean
git clean -fdx
` ` `

spry run file.md              # Runs main graph
spry 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
echo "Deploying version ${env.APP_VERSION}"
` ` `

```bash greet -I
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
}