### Run Specific Test Suites with Cargo

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash commands to execute specific test suites by name pattern. Includes examples for running FuzzyReplaceTool tests (18 tests), TraceCallPathTool tests (15 tests), and language extractor tests.

```bash
# Specific test suites
cargo test fuzzy_replace          # FuzzyReplaceTool unit tests (18 tests)
cargo test trace_call_path        # TraceCallPathTool unit tests (15 tests)
cargo test typescript_extractor   # Language extractor tests
```

--------------------------------

### Example Exploration Session: Authentication

Source: https://github.com/anortham/julie/blob/main/skills/explore-codebase/SKILL.md

A detailed example of how the 'Explore Codebase' skill is used to understand the authentication mechanism in a codebase, demonstrating the step-by-step application of Julie's tools from semantic search to finding usage points.

```javascript
User: "How does authentication work in this codebase?"

Skill activates → Systematic exploration

Step 1: Semantic Search
→ fast_search({ query: "authentication logic", mode: "semantic" })

Results:
- src/middleware/auth.ts (score: 0.95)
- src/services/user-service.ts (score: 0.89)
- src/utils/jwt.ts (score: 0.87)

Step 2: Symbol Structure (Token-Efficient)
→ get_symbols({ file: "src/middleware/auth.ts", mode: "structure" })

Structure:
- class AuthMiddleware
  - authenticate(): middleware function
  - validateToken(): token validation
  - extractUser(): user extraction
- imports: jwt, UserService

Step 3: Trace Execution Flow
→ trace_call_path({
    symbol: "authenticate",
    direction: "downstream"
  })

Execution flow:
authenticate() 
  → validateToken() 
    → jwt.verify()
  → extractUser()
    → UserService.findById()

Step 4: Find Usage Points
→ fast_refs({ symbol: "authenticate" })

Used in:
- src/routes/api.ts (10 locations)
- src/routes/admin.ts (5 locations)
- src/app.ts (1 location - middleware registration)

Analysis: "Authentication uses JWT middleware that validates tokens
via the UserService. The authenticate function is registered globally
in app.ts and protects 15 routes across api and admin routers."
```

--------------------------------

### Install Julie Skills Globally

Source: https://github.com/anortham/julie/blob/main/README.md

Installs Julie's skills globally by creating a `~/.claude/skills` directory and copying the skills from the Julie project into it. This makes the skills available across all projects where Julie is configured, allowing AI agents to leverage them automatically.

```bash
# Install skills globally (works across all projects where Julie is configured)
mkdir -p ~/.claude/skills
cp -r /path/to/julie/skills/* ~/.claude/skills/
```

--------------------------------

### Example Unified Standup Output

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Markdown-formatted output of the unified standup report, detailing recent activity and completed tasks for different components like Julie, Tusk, and Goldfish.

```markdown
## Developer Standup - Last 7 Days

### Julie (Code Intelligence)
- Added memory system architecture
- Implemented checkpoint/recall tools
- Fixed HNSW index rebuild performance

### Tusk (Memory System)
- Migrated from SQLite to JSONL storage
- Added git context capture
- Improved session detection

### Goldfish (Previous Iteration)
- Archived in favor of Julie integration

```

--------------------------------

### Run Performance Tests with Release Optimization

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to execute tests with Rust release optimizations enabled. Used for performance benchmarking and validation of test execution speed.

```bash
cargo test --release
```

--------------------------------

### Run All Tests Including Slow Dogfooding Tests

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to execute the complete test suite including both fast unit tests and slow dogfooding tests. Should be run before major releases to ensure comprehensive validation.

```bash
cargo test --lib -- --include-ignored
```

--------------------------------

### Run All Tests with Cargo

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to execute all tests in the project using Cargo. This is the primary command for running the complete test suite during development and CI/CD pipelines.

```bash
cargo test
```

--------------------------------

### Run Tests with Output Display

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to execute tests while displaying print statements and debug output. Useful for debugging test failures and understanding test execution flow.

```bash
cargo test -- --nocapture
```

--------------------------------

### Orchestration: New to Codebase Onboarding Flow

Source: https://github.com/anortham/julie/blob/main/skills/explore-codebase/SKILL.md

Step-by-step orchestration example for a new developer exploring an unfamiliar codebase. Uses fast_explore for business logic overview, get_symbols for entry point identification, and trace_call_path to understand initialization flow, culminating in a comprehensive project summary.

```plaintext
1. fast_explore({ mode: "logic", domain: "core" }) → Business logic overview
2. get_symbols(file="src/main.ts", mode="structure") → Entry point
3. trace_call_path on main() → See initialization flow
4. Present: "This is a [type] application with [layers].
   Main entry point initializes [components] and starts [server]."
```

--------------------------------

### Generate Detailed HTML Coverage Report

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to run Tarpaulin code coverage analysis and generate a detailed HTML report. Outputs coverage visualization to target/tarpaulin directory for in-depth analysis.

```bash
cargo tarpaulin --output-dir target/tarpaulin --output-format Html
```

--------------------------------

### Rust Module Structure Example

Source: https://github.com/anortham/julie/blob/main/CLAUDE.md

This Rust code snippet illustrates a well-organized module structure. It shows a 'database' module with distinct sub-modules for public API, schema definitions, migrations, and query operations, adhering to the single responsibility principle. This contrasts with a 'bad' example where a single file contains excessive functionality.

```rust
// ✅ GOOD: Clear, focused responsibility
src/database/
		├── mod.rs          # Public API, re-exports
		├── schema.rs       # Schema definitions only
		├── migrations.rs   # Migration logic only
		└── queries.rs      # Query operations only

// ❌ BAD: God object
src/database/
		└── mod.rs          # 4,837 lines of everything
```

--------------------------------

### Run Slow Dogfooding Tests Only

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to execute only the ignored slow/dogfooding tests (16 tests total) for search quality validation. These tests validate Julie's functionality against its own codebase with real-world scenarios.

```bash
cargo test --lib -- --ignored
```

--------------------------------

### Julie Ignore Patterns Example

Source: https://github.com/anortham/julie/blob/main/README.md

Example of custom ignore patterns for the Julie workspace, using glob syntax for file exclusions. These patterns are defined in a `.julieignore` file and complement the default ignore patterns.

```ignore
# .julieignore example
experimental/
legacy-code/
third-party/
*.generated.ts
```

--------------------------------

### SQL View for Plan Searchability

Source: https://github.com/anortham/julie/blob/main/skills/plan-tracking/SKILL.md

Demonstrates how plans are indexed in SQL views for efficient searching. It shows a SQL query to create a 'plan_memories' view and an example of using 'fast_search' to query plan content.

```sql
-- View: plan_memories
SELECT id, timestamp, title, status FROM plans;

-- Searchable via fast_search
fast_search({
  query: "database migration",
  search_method: "text",
  file_pattern: ".memories/plans/**/*.json"
})

→ Plans are searchable just like checkpoints
→ Semantic search works on plan content
```

--------------------------------

### Julie CLI Cross-Workspace Commands (Rust)

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Illustrates how to use the Julie command-line interface (CLI) to perform actions across multiple registered workspaces. It shows examples for searching and recalling information with flags like `--all-workspaces` and `--workspaces`.

```rust
// Single workspace (default)
julie fast_search "auth implementation"

// All registered workspaces
julie fast_search "auth implementation" --all-workspaces

// Specific workspaces
julie fast_search "auth implementation" --workspaces julie,tusk

// Cross-workspace recall
julie recall --all-workspaces --since "2025-01-01"

```

--------------------------------

### Check Specific Module Code Coverage

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to analyze code coverage for a specific module or file. Useful for verifying coverage thresholds for critical components like the editing tools module.

```bash
cargo tarpaulin --include src/tools/editing.rs
```

--------------------------------

### Generate Code Coverage Analysis

Source: https://github.com/anortham/julie/blob/main/docs/TESTING_GUIDE.md

Bash command to run Tarpaulin code coverage analysis tool. Generates coverage reports in multiple formats (HTML, LCOV, JSON) to verify test coverage meets project thresholds.

```bash
cargo tarpaulin
```

--------------------------------

### Plan for Mutable Development Plans (JavaScript)

Source: https://github.com/anortham/julie/blob/main/DOCUMENTATION_AUDIT.md

The plan tool manages mutable development plans, to be used after `ExitPlanMode`. Plans represent significant work and should be saved promptly. Only one active plan is supported at a time. Actions include save, get, list, activate, update, and complete.

```javascript
```javascript
plan({
  action: "save",
  title: "Add Search Feature",
  content: "## Tasks\n- [ ] Design\n- [ ] Implement"
})
```
```

--------------------------------

### Plan Storage Location and File Naming

Source: https://github.com/anortham/julie/blob/main/skills/plan-tracking/SKILL.md

Shows the default storage location for plan files (`.memories/plans/`) and provides examples of plan filenames. It highlights key points like stable, human-readable, and Git-trackable filenames.

```plaintext
.memories/plans/
├── plan_add-search-feature.json
├── plan_refactor-database.json
└── plan_user-profile-page.json

**Key points:**
- Stable filenames (slug from title)
- Git-trackable (team can see plans)
- Human-readable (can edit manually if needed)
- Mutable (update in-place)
```

--------------------------------

### Rust Test-First Example for Function Extraction

Source: https://github.com/anortham/julie/blob/main/CLAUDE.md

This Rust code demonstrates the Test-Driven Development (TDD) approach by showing a failing test case written before the implementation. The test `test_extract_typescript_functions` is designed to verify the extraction of function symbols from TypeScript code. It is expected to fail initially, guiding the developer to write the necessary implementation.

```rust
// ✅ CORRECT: Test first, then implement
#[cfg(test)]
mod tests {
	#[test]
	fn test_extract_typescript_functions() {
		let code = "function getUserData() { return data; }";
		let symbols = extract_symbols(code);
		assert_eq!(symbols.len(), 1);
		assert_eq!(symbols[0].name, "getUserData");
		// This WILL FAIL initially - that's the point!
	}
}
```

--------------------------------

### Build Julie Server from Source

Source: https://github.com/anortham/julie/blob/main/README.md

Provides bash commands to clone the Julie repository from GitHub, navigate into the project directory, and compile the release version of the `julie-server` binary using Cargo. The compiled executable will be located in the `target/release/` directory.

```bash
git clone https://github.com/anortham/julie.git
cd julie
cargo build --release
# Binary will be at: target/release/julie-server[.exe]
```

--------------------------------

### Fuzzy Replace Validation Error Example

Source: https://github.com/anortham/julie/blob/main/skills/safe-refactor/SKILL.md

Provides an example of an error message encountered during `fuzzy_replace` operations when the code similarity falls below the specified threshold. It suggests steps to troubleshoot, such as verifying the `old_string` and adjusting the threshold.

```plaintext
Error: "Similarity 0.65 below threshold 0.75"
→ Check old_string matches current code
→ Adjust threshold or fix old_string
→ Verify no unexpected changes in file
```

--------------------------------

### Get Code Structure (Get Symbols)

Source: https://github.com/anortham/julie/blob/main/skills/semantic-intelligence/SKILL.md

Retrieves symbols (like functions, classes) from a specified file path up to a certain depth. Useful for understanding the structural organization of code within a file.

```javascript
get_symbols({ file_path: "main.ts", max_depth: 2 })
```

--------------------------------

### Julie Development Build Commands

Source: https://github.com/anortham/julie/blob/main/README.md

Commands for cloning the Julie repository, performing a development build, running tests, and creating a production build using Cargo.

```bash
# Clone repository
git clone https://github.com/anortham/julie.git
cd julie

# Development build
cargo build

# Run tests
cargo test

# Production build
cargo build --release
```

--------------------------------

### Example Extractor Test Pattern (Rust)

Source: https://github.com/anortham/julie/blob/main/docs/RELATIVE_PATHS_CONTRACT.md

Provides an example Rust test case demonstrating the required verifications for the relative path contract. The test checks that the `Symbol.file_path` is relative, uses Unix separators, is within the workspace, and that round-trip conversion works correctly.

```rust
@test
fn test_typescript_extractor_stores_relative_paths() {
    let workspace_root = PathBuf::from("/home/murphy/source/julie");
    let file_path = workspace_root.join("src/tools/search.rs");
    let content = "function getUserData() { return data; }";

    let mut extractor = TypeScriptExtractor::new(
        "typescript".to_string(),
        file_path.to_string_lossy().to_string(),
        content.to_string(),
        &workspace_root,
    );

    let symbols = extractor.extract_symbols(&tree);

    // Contract verification
    assert_eq!(symbols[0].file_path, "src/tools/search.rs");
    assert!(!symbols[0].file_path.contains('\\'), "No backslashes");
    assert!(symbols[0].file_path.contains('/'), "Uses forward slashes");
    assert!(!symbols[0].file_path.starts_with('/'), "Not absolute");
}
```

--------------------------------

### Core Skills Library - TDD Skill Implementation

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Implements the TDD skill with specific Julie commands for fast searching, test execution, semantic recall, call path tracing, and checkpointing. Shows how tool descriptions and explicit skill invocation replace hook-based automation.

```markdown
1. julie fast_search "test" --type test
2. Run test suite, capture failures
3. julie recall --semantic "{error_message}"
4. julie trace_call_path {failing_function}
5. Implement fix
6. julie checkpoint "Fixed {test_name}: {solution}"
```

--------------------------------

### Release Preparation with Cargo

Source: https://github.com/anortham/julie/blob/main/docs/DEVELOPMENT.md

Commands for preparing optimized and cross-platform release builds. Includes size optimization checks using 'cargo bloat'.

```bash
# Optimized build
cargo build --release

# Cross-platform builds
cargo build --target x86_64-pc-windows-msvc --release
cargo build --target x86_64-unknown-linux-gnu --release

# Size optimization
cargo bloat --release
```

--------------------------------

### Get Symbols API

Source: https://github.com/anortham/julie/blob/main/skills/semantic-intelligence/SKILL.md

Retrieves information about symbols (functions, classes, variables) within a specific file, including their structure and depth.

```APIDOC
## `get_symbols` Function

### Description
Retrieves a structured list of symbols (functions, classes, etc.) defined within a specified file, up to a certain depth. Useful for understanding the structure of a single file.

### Method
`get_symbols({ file_path: string, max_depth?: number })`

### Parameters

#### Query Parameters

- **file_path** (string) - Required - The path to the file to analyze.
- **max_depth** (number) - Optional - The maximum nesting depth of symbols to retrieve. Defaults to a reasonable limit.

### Request Example

```json
{
  "file_path": "main.ts",
  "max_depth": 2
}
```

### Response

#### Success Response (200)

- **symbols** (array) - A nested structure representing the symbols found in the file.

#### Response Example

```json
{
  "symbols": [
    {
      "name": "main",
      "type": "function",
      "children": [
        {
          "name": "initApp",
          "type": "function",
          "children": []
        }
      ]
    }
  ]
}
```
```

--------------------------------

### Creating an Observation Memory

Source: https://github.com/anortham/julie/blob/main/skills/development-memory/SKILL.md

Example of creating an 'observation' memory, used to record noticed patterns, code smells, or potential issues. It includes fields for the observation itself and its potential impact.

```javascript
checkpoint({
  type: "observation",
  observation: "Repeated database connection errors under load.",
  impact: "Potential for service outages during peak hours.",
  tags: ["code-smell", "security"]
})
```

--------------------------------

### Semantic and Text Search Queries

Source: https://github.com/anortham/julie/blob/main/CLAUDE.md

Demonstrates how to use the `fast_search` function for both semantic and text-based searches within documentation files. It specifies search targets and file patterns for targeted information retrieval.

```rust
// Ask conceptual questions
fast_search(
    query="How does workspace routing work?",
    search_method="semantic",
    search_target="definitions",
    file_pattern="docs/**"
)

// Find specific documentation
fast_search(
    query="SOURCE/CONTROL testing methodology",
    search_method="text",
    search_target="content",
    file_pattern="docs/*.md"
)
```

--------------------------------

### Get Symbols API

Source: https://github.com/anortham/julie/blob/main/skills/semantic-intelligence/SKILL.md

Retrieves a list of symbols (e.g., functions, classes, variables) within a specified scope or file, optionally filtered by type or name patterns.

```APIDOC
## POST /api/get_symbols

### Description
Retrieves a list of symbols (functions, classes, variables, etc.) from the codebase. Allows filtering by file, scope, or name pattern for targeted symbol discovery.

### Method
POST

### Endpoint
/api/get_symbols

### Parameters
#### Query Parameters
- **file_path** (string) - Optional - The path to the file to retrieve symbols from.
- **name_pattern** (string) - Optional - A pattern to filter symbols by name.
- **symbol_type** (string) - Optional - The type of symbol to retrieve (e.g., 'function', 'class', 'variable').

### Request Body
```json
{
  "file_path": "string",
  "name_pattern": "string",
  "symbol_type": "string"
}
```

### Request Example
```json
{
  "file_path": "src/utils/helpers.js",
  "symbol_type": "function"
}
```

### Response
#### Success Response (200)
- **symbols** (array) - A list of symbol objects, each containing the symbol's name, type, and location.

#### Response Example
```json
{
  "symbols": [
    {
      "name": "formatDate",
      "type": "function",
      "file": "src/utils/helpers.js",
      "line": 15
    }
  ]
}
```
```

--------------------------------

### Search for Code Implementations

Source: https://github.com/anortham/julie/blob/main/JULIE_AGENT_INSTRUCTIONS.md

The `fast_search` function allows for efficient searching of code implementations within the workspace. It supports various query types and limits, enabling quick location of relevant code snippets.

```javascript
fast_search(query="...", search_method="text", limit=15)
```

--------------------------------

### Discover Codebase Logic and Similarities

Source: https://github.com/anortham/julie/blob/main/JULIE_AGENT_INSTRUCTIONS.md

The `fast_explore` function aids in discovering unfamiliar codebases by identifying business logic, semantically similar code, or analyzing dependencies. It supports different modes like 'logic', 'similar', and 'dependencies', with parameters for domain, symbol, threshold, and depth.

```javascript
// Find payment processing logic
fast_explore(mode="logic", domain="payment processing")
```

```javascript
// Find duplicate code
fast_explore(mode="similar", symbol="getUserData", threshold=0.8)
```

```javascript
// Analyze dependencies
fast_explore(mode="dependencies", symbol="PaymentService", depth=3)
```

--------------------------------

### Integration with Safe Refactor

Source: https://github.com/anortham/julie/blob/main/skills/development-memory/SKILL.md

Details how the memory workflow supports safe refactoring. It recommends recalling previous refactoring efforts for a given module before starting, and checkpointing the new refactoring with relevant metrics.

```text
Before refactor: recall({ tags: ["refactor", module] })
After refactor: checkpoint({ type: "refactor", metrics: "..." })
```

--------------------------------

### Bash: Manual Testing Workflow

Source: https://github.com/anortham/julie/blob/main/docs/ADDING_NEW_LANGUAGES.md

This sequence of bash commands demonstrates the manual testing workflow: creating a test file, indexing the workspace using `cargo run --release`, and verifying extracted symbols via SQLite.

```bash
# 1. Create test file:
echo "test code" > test.ml

# 2. Index workspace:
# Use MCP to index workspace
cargo run --release

# 3. Verify extraction:
# Check database for symbols
sqlite3 .julie/indexes/primary_*/db/symbols.db "SELECT * FROM symbols WHERE file_path LIKE '%test.ml%';"
```

--------------------------------

### Creating a Decision Memory

Source: https://github.com/anortham/julie/blob/main/skills/development-memory/SKILL.md

Example of creating a 'decision' memory, which is used to record architectural or technical decisions. It includes fields for the question asked, the chosen solution, alternatives considered, and the rationale behind the decision.

```javascript
checkpoint({
  type: "decision",
  question: "Choose database for new service",
  chosen: "PostgreSQL",
  alternatives: ["MongoDB", "MySQL"],
  rationale: "Scalability and ACID compliance",
  tags: ["architecture", "database"]
})
```

--------------------------------

### Creating a Checkpoint Memory

Source: https://github.com/anortham/julie/blob/main/skills/development-memory/SKILL.md

An example of how to create a 'checkpoint' memory using the `checkpoint` function. This is the default memory type and is used for general-purpose logging of significant work, including descriptions and tags for easy searching.

```javascript
checkpoint({
  description: "what you did",
  tags: ["bug", "auth"],
  learnings: "root cause was X"
})
```

--------------------------------

### Core Skills Library - Architecture Skill Implementation

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Implements the architecture skill for documenting architectural decisions with cross-workspace pattern search, decision recall by type and tags, and decision checkpointing. Demonstrates how skills preserve architectural context.

```markdown
1. julie fast_search "similar patterns" --all-workspaces
2. julie recall --type decision --tags architecture
3. Document decision
4. julie checkpoint --type decision "Chose {option} because {reasons}"
```

--------------------------------

### Rename Symbol Failure Error Example

Source: https://github.com/anortham/julie/blob/main/skills/safe-refactor/SKILL.md

Illustrates a common error message when using `rename_symbol` if the specified symbol is not found. It advises on how to resolve this by checking the symbol's existence, spelling, and scope.

```plaintext
Error: "Symbol not found: oldName"
→ Verify symbol exists with fast_goto
→ Check spelling and casing
→ Ensure symbol is in scope
```

--------------------------------

### Get - Retrieve Specific Plan

Source: https://github.com/anortham/julie/blob/main/skills/plan-tracking/SKILL.md

Retrieves a specific plan by ID to check its current status, content, and timestamp. Used for viewing plan details without modifications.

```json
plan({
  action: "get",
  id: "plan_add-search-feature"
})
```

--------------------------------

### Unified Standup Generation Command

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Command-line interface for generating a unified standup report across all configured workspaces. It takes the number of days for the report as an argument.

```bash
julie standup --all-workspaces --days 7
```

--------------------------------

### Configure Julie Server in VS Code

Source: https://github.com/anortham/julie/blob/main/README.md

Sets up the Julie language server for VS Code by creating a workspace-level `.vscode/mcp.json` file. This configuration specifies the server command, arguments, and environment variables, ensuring proper integration with the VS Code workspace. The `JULIE_WORKSPACE` environment variable is crucial for directing Julie to create its data directory within the project.

```json
{
  "servers": {
    "Julie": {
      "type": "stdio",
      "command": "/path/to/julie-server",
      "args": [],
      "env": {
        "JULIE_WORKSPACE": "${workspaceFolder}"
      }
    }
  }
}
```

--------------------------------

### Core Skills Library - Debug Skill Implementation

Source: https://github.com/anortham/julie/blob/main/docs/JULIE_2_PLAN.md

Implements the debug skill workflow for intelligent debugging using fast search, semantic recall across workspaces, call path tracing, and symbol analysis. Demonstrates multi-workspace memory integration for error pattern recognition.

```markdown
1. julie fast_search "{error_pattern}"
2. julie recall --semantic "{error_message}" --all-workspaces
3. julie trace_call_path {stack_trace_function}
4. julie get_symbols {suspicious_file}
5. Identify root cause
6. julie checkpoint "Bug: {cause}, Solution: {fix}"
```

--------------------------------

### Reference Conflict Warning Example

Source: https://github.com/anortham/julie/blob/main/skills/safe-refactor/SKILL.md

Shows a warning message generated by `rename_symbol` when it detects a large number of references across multiple files. It recommends user confirmation and considering smaller renames or scope adjustments.

```plaintext
Warning: "Found 47 references across 15 files"
→ Confirm with user before proceeding
→ Consider splitting into smaller renames
→ Verify scope is correct
```

--------------------------------

### Token Efficiency Comparison: Traditional vs Julie Approach

Source: https://github.com/anortham/julie/blob/main/skills/explore-codebase/SKILL.md

Compares token usage between traditional file reading and Julie's symbol-based approach. The traditional method reads an entire 500-line file consuming 12,000 tokens, while Julie's get_symbols achieves 93% token savings by extracting only the structure and relevant symbols, enabling navigation without full file parsing.

```plaintext
Read entire file (500 lines) → 12,000 tokens
Analyze → Extract relevant parts
```

```plaintext
get_symbols(mode="structure") → 800 tokens (93% savings!)
See structure → Navigate precisely
Only read specific symbols if needed
```

--------------------------------

### Open Reference Workspace Database Connection (Rust)

Source: https://github.com/anortham/julie/blob/main/docs/SQLITE_USAGE_GUIDELINES.md

This Rust code shows the correct way to open a connection to a reference workspace's database. It emphasizes using `SymbolDatabase::new()` and correctly constructs the path to the reference database file. The operation is performed within a `tokio::task::spawn_blocking` to avoid blocking the async runtime on potentially lengthy file I/O.

```rust
// ✅ CORRECT: Via SymbolDatabase::new()
let ref_db_path = workspace.workspace_db_path(&ref_workspace_id);
let ref_db = tokio::task::spawn_blocking(
    move || SymbolDatabase::new(ref_db_path)
).await??;
```

--------------------------------

### Recall for Memory Retrieval (JavaScript)

Source: https://github.com/anortham/julie/blob/main/DOCUMENTATION_AUDIT.md

The recall tool retrieves past development memory, recommended to be used at the start of every work session. It helps in referencing similar past work and avoiding previous mistakes. Supports chronological and semantic queries.

```javascript
```javascript
recall({ limit: 10 })  // Session start
recall({ since: "2025-01-01", type: "decision" })  // Filtered
```
```

--------------------------------

### Run Benchmark Suite

Source: https://github.com/anortham/julie/blob/main/docs/PERFORMANCE.md

Executes the benchmark suite for the project using Cargo. This command is used to measure and verify the performance of various components against defined targets.

```bash
# Benchmark suite
cargo bench

```

--------------------------------

### Recalling Past Information

Source: https://github.com/anortham/julie/blob/main/skills/development-memory/SKILL.md

Leverage past knowledge by recalling similar bugs, architectural decisions, or recent activity before starting new work or investigating existing code. This helps avoid repeating mistakes and understand historical context.

```javascript
recall({
  type: "checkpoint",
  tags: ["bug", "auth"],
  limit: 5
})

recall({
  type: "decision",
  since: "2024-01-01",
  limit: 10
})

recall({
  limit: 10
})
```