obsidian-base-create

Generates Obsidian .base files from natural language descriptions. Translates requests like "show me all active project notes sorted by date" into valid .base YAML with filters, formulas, views, and s

SKILL.md

GitHub

Obsidian Base Create

<purpose> Bases bring database-style views to Obsidian — tables, cards, lists, maps — all powered by note frontmatter. The .base format is YAML but the syntax is non-obvious: nested filter logic, formula functions, property references, view configurations. This skill translates what you want to see into working .base files. </purpose>

When To Activate

<triggers> - User says "create base", "make a base", "new base" - User says "show me all notes where...", "filter my notes", "dashboard" - User says "I want a table of...", "list all my...", "view of..." - User wants to track tasks, projects, readings, meetings across notes - After vault init when creating starter views </triggers>

Do NOT trigger for:

  • Editing existing .base files (edit directly)
  • Simple search queries (use obsidian-vault-search)
  • Views that don't depend on frontmatter properties

Instructions

Step 1: Understand What the User Wants to See

<clarify> Map the request to a base configuration:
Request View Type Key Filter Sort
"All my meetings" table type == meeting date desc
"Active projects" cards type == project AND status == active name asc
"Tasks this week" table type == task AND date >= week start date asc
"Recent notes" table (none or date-based) file.mtime desc
"Reading list" cards type == reference AND status == draft created desc

Ask if not obvious:

  • What properties should show as columns?
  • How should it be sorted?
  • Table, cards, or list view?</clarify>

Step 2: Check Available Properties

<properties> Before building filters, check what properties actually exist in the vault:
# Find all frontmatter properties used in the vault
grep -rh "^[a-z].*:" "$VAULT_PATH" --include="*.md" | \
  grep -v "^#\|^-\|^ " | sort | uniq -c | sort -rn | head -20

Common properties from the vault schema (check CLAUDE.md):

  • type: note, meeting, project, daily, reference, task
  • status: draft, active, completed, archived
  • date: YYYY-MM-DD
  • created: YYYY-MM-DD
  • project: project name
  • tags: array of tags
  • attendees: list (meetings)

Don't create filters on properties that don't exist in the vault. </properties>

Step 3: Build the Base YAML

<build> Base file structure:
# Global filter (applies to all views)
filter:
  - property: <name>
    operator: "<op>"
    value: "<value>"

# Computed properties
formulas:
  formula-name: '<expression>'

# View configurations
views:
  - name: "View Name"
    type: table  # table, cards, list, map
    properties:
      - file.name
      - property-name
    sort:
      - property: <name>
        order: asc  # or desc
    filter:  # view-specific filter (in addition to global)
      - property: <name>
        operator: "<op>"
        value: "<value>"

Filter operators:

Operator Meaning
== equals
!= not equals
> greater than
< less than
>= greater or equal
<= less or equal

Compound filters (AND/OR/NOT):

filter:
  # AND (default — sequential conditions)
  - property: type
    operator: "=="
    value: meeting
  - property: status
    operator: "=="
    value: active

  # OR (explicit)
  - operator: OR
    conditions:
      - property: type
        operator: "=="
        value: meeting
      - property: type
        operator: "=="
        value: project

  # NOT
  - operator: NOT
    conditions:
      - property: status
        operator: "=="
        value: archived

File metadata properties:

file.name     — Note filename without extension
file.path     — Full path from vault root
file.mtime    — Last modified time
file.ctime    — Creation time
file.size     — File size in bytes
file.folder   — Parent folder path
file.ext      — File extension
</build>

Step 4: Add Formulas (if needed)

<formulas> Formulas are computed properties that derive values from existing data:
formulas:
  # Days since creation
  age: '(now() - this.created).days'

  # Status badge
  badge: 'if(this.status == "active", "🟢", if(this.status == "draft", "🟡", "⚪"))'

  # Overdue check
  overdue: 'if(this.date < today(), "⚠️ Overdue", "On track")'

  # Tag count
  tag-count: 'this.tags.length'

  # Full name from path
  display: 'this.file.name'

Useful formula functions:

  • Date: now(), today(), date("YYYY-MM-DD"), format(date, "MMM DD"), relative(date)
  • String: contains(str, substr), replace(str, old, new), lower(str), trim(str)
  • Number: abs(), ceil(), floor(), round()
  • List: filter(), map(), join(), sort(), .length
  • File: hasTag(tag), hasProperty(prop), inFolder(path), asLink()
  • Logic: if(condition, then, else)

The this keyword refers to the current row's note. </formulas>

Step 5: Configure View

<views> **Table view** (best for data-heavy views): ```yaml views: - name: "All Meetings" type: table properties: - file.name - date - attendees - project - status sort: - property: date order: desc ```

Cards view (best for visual browsing):

views:
  - name: "Active Projects"
    type: cards
    properties:
      - file.name
      - status
      - tags
    sort:
      - property: file.name
        order: asc

List view (best for simple lists):

views:
  - name: "Quick List"
    type: list
    properties:
      - file.name
    sort:
      - property: file.mtime
        order: desc

Multiple views (same base, different perspectives):

views:
  - name: "Table"
    type: table
    properties: [file.name, status, date]
    sort: [{property: date, order: desc}]

  - name: "Cards"
    type: cards
    properties: [file.name, status]
    sort: [{property: status, order: asc}]

Summaries (aggregate values shown at column bottom):

views:
  - name: "Project Budget"
    type: table
    properties:
      - file.name
      - budget
      - spent
    summaries:
      budget: sum
      spent: sum

Summary types: average, min, max, sum, range, median, count, earliest, latest, checked, unchecked, empty, filled, unique </views>

Step 6: Write and Verify

<write> ```bash # Name the base file descriptively BASE_PATH="$VAULT_PATH/base-name.base" ```

Write the YAML. Then verify by checking the YAML is valid:

python3 -c "import yaml; yaml.safe_load(open('$BASE_PATH'))" && echo "Valid YAML"

Confirm:

Base created: base-name.base

View: [table / cards / list]
Filter: [what's filtered]
Columns: [listed properties]
Sort: [sort order]

Open in Obsidian to see your data.
</write>

Output Format

## Base Created

**File:** base-name.base
**View:** [table / cards / list / map]
**Filter:** [description of filter logic]
**Columns:** [list of shown properties]
**Sort:** [property, direction]
**Formulas:** [any computed properties]

Open in Obsidian to interact with the view.

NEVER

  • Create filters on properties that don't exist in the vault
  • Write invalid YAML (always validate)
  • Skip checking what properties exist first
  • Use complex formulas without explaining what they compute
  • Create a base without at least one view configured
  • Assume property names — check CLAUDE.md or scan existing notes

ALWAYS

  • Check what frontmatter properties exist in the vault first
  • Validate the YAML output
  • Include at least file.name in every view's properties
  • Use descriptive view names
  • Explain the filter logic in plain English
  • Suggest additional views or formulas that might be useful

Example

User: "Make me a dashboard showing all active projects with their status and last modified date"

filter:
  - property: type
    operator: "=="
    value: project
  - property: status
    operator: "!="
    value: archived

formulas:
  last-active: 'relative(this.file.mtime)'

views:
  - name: "Active Projects"
    type: table
    properties:
      - file.name
      - status
      - project
      - tags
      - last-active
    sort:
      - property: file.mtime
        order: desc

  - name: "Project Cards"
    type: cards
    properties:
      - file.name
      - status
      - last-active
    sort:
      - property: status
        order: asc
Base created: project-dashboard.base

View 1: "Active Projects" (table)
  Filter: type == project AND status != archived
  Columns: name, status, project, tags, last active (relative time)
  Sort: last modified (newest first)

View 2: "Project Cards" (cards)
  Same filter, card layout for visual browsing

Open in Obsidian to see your projects.
<failed-attempts> What DOESN'T work: - Filtering on `content` or note body — Bases only filters on frontmatter properties and file metadata - Using Dataview syntax (`FROM`, `WHERE`) — Bases has its own YAML syntax, not Dataview - Assuming properties exist — if notes don't have `status` in frontmatter, the filter returns nothing - Complex nested formulas without testing — start simple, iterate </failed-attempts>