loctree 0.8.16

Structural code intelligence for AI agents. Scan once, query everything.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! CLI module for the new subcommand-based interface.
//!
//! This module provides the canonical `loct <command> [options]` interface
//! while maintaining backward compatibility with legacy flags through an adapter.
//!
//! # Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────────┐
//! │                        User Input (argv)                        │
//! └─────────────────────────────────────────────────────────────────┘
//!                                  │
//!                                  ▼
//! ┌─────────────────────────────────────────────────────────────────┐
//! │                         CLI Parser                              │
//! │  ┌─────────────────┐    ┌─────────────────────────────────┐    │
//! │  │ New Subcommands │    │ Legacy Adapter (args::legacy)   │    │
//! │  │ loct scan       │    │ -A --dead → loct dead           │    │
//! │  │ loct tree       │    │ --tree → loct tree              │    │
//! │  │ loct slice      │    │ --for-ai → loct slice --json    │    │
//! │  └────────┬────────┘    └────────────────┬────────────────┘    │
//! │           │                              │                      │
//! │           └──────────────┬───────────────┘                      │
//! │                          ▼                                      │
//! │              ┌───────────────────────┐                          │
//! │              │  Command + Options    │                          │
//! │              │  (Unified internal    │                          │
//! │              │   representation)     │                          │
//! │              └───────────┬───────────┘                          │
//! └──────────────────────────┼──────────────────────────────────────┘
//!                            │
//!                            ▼
//! ┌─────────────────────────────────────────────────────────────────┐
//! │                     Command Handlers                            │
//! │  analyzer::run_import_analyzer, tree::run_tree, slicer::...,   │
//! │  snapshot::..., etc.                                            │
//! └─────────────────────────────────────────────────────────────────┘
//! ```
//!
//! # Design Principles
//!
//! 1. **Agent-first**: The tool is primarily for AI agents. Humans get a
//!    minimal interface (5 core commands).
//!
//! 2. **Minimal commands, exclusive flags**: Flags modify/exclude default
//!    behavior, they don't add functionality.
//!
//! 3. **Regex on metadata**: Agents can filter using regex on symbol names,
//!    paths, namespaces - but never on raw source code.
//!
//! 4. **Legacy compatibility**: Old flags work with deprecation warnings
//!    until v1.0 when the adapter is removed.
//!
//! # Module Structure
//!
//! - [`command`] - Command enum and option types (source of truth)
//! - [`parser`] - New subcommand parser
//! - [`dispatch`] - Command dispatcher and ParsedArgs converter
//! - `legacy` (future) - Legacy flag adapter

pub mod command;
pub mod dispatch;
pub mod entrypoint;
pub mod parser;

// Re-export main types for convenience
pub use command::{
    // Per-command options
    AutoOptions,
    // Command enum
    Command,
    CommandsOptions,
    CyclesOptions,
    DeadOptions,
    EventsOptions,
    FindOptions,
    FindingsOptions,
    // Global options
    GlobalOptions,
    HelpOptions,
    InfoOptions,
    LintOptions,
    MemexOptions,
    // Parsing result
    ParsedCommand,
    ReportOptions,
    ScanOptions,
    SliceOptions,
    TreeOptions,
};

// Re-export parser functions
pub use parser::{is_subcommand, parse_command, uses_new_syntax};

// Re-export dispatch functions
pub use dispatch::{DispatchResult, command_to_parsed_args, dispatch_command};