busbar-sf-agentscript 0.0.2

AgentScript parser, graph analysis, and LSP for Salesforce Agentforce
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Primitive parsers for basic tokens.
//!
//! This module contains parsers for identifiers, strings, numbers,
//! newlines, indentation, and noise-skipping utilities.

use crate::ast::Spanned;
use crate::lexer::Token;
use chumsky::input::MappedInput;
use chumsky::prelude::*;

/// Token span type (from lexer).
pub type Span = SimpleSpan<usize>;

/// Spanned token type.
pub type SpannedToken<'src> = (Token<'src>, Span);

/// Parser input type - a slice of spanned tokens mapped into chumsky format.
/// Created by calling `tokens.split_token_span(eoi_span)` on a token slice.
pub type ParserInput<'tokens, 'src> =
    MappedInput<'tokens, Token<'src>, Span, &'tokens [SpannedToken<'src>]>;

/// Convert a chumsky SimpleSpan to our AST Span (Range<usize>).
pub fn to_ast_span(span: Span) -> std::ops::Range<usize> {
    span.start..span.end
}

/// Parse an identifier token.
pub fn ident<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    &'src str,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    select! {
        Token::Ident(s) => s,
    }
}

/// Parse an identifier as a spanned string.
pub fn spanned_ident<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    Spanned<String>,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    ident().map_with(|s, e| Spanned::new(s.to_string(), to_ast_span(e.span())))
}

/// Parse a string literal.
pub fn string_lit<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    &'src str,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    select! {
        Token::StringLit(s) => s,
    }
}

/// Parse a spanned string literal.
pub fn spanned_string<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    Spanned<String>,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    string_lit().map_with(|s, e| Spanned::new(s.to_string(), to_ast_span(e.span())))
}

/// Parse a number literal.
pub fn number_lit<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    f64,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    select! {
        Token::NumberLit(n) => n,
    }
}

/// Parse a newline token (for line tracking).
pub fn newline<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    just(Token::Newline).ignored()
}

/// Skip optional newlines.
#[allow(dead_code)]
pub fn skip_newlines<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    newline().repeated().ignored()
}

/// Parse an INDENT token.
pub fn indent<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    just(Token::Indent).ignored()
}

/// Parse a DEDENT token.
pub fn dedent<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    just(Token::Dedent).ignored()
}

/// Skip noise tokens (newlines, indents, dedents, comments) between blocks.
#[allow(dead_code)]
pub fn skip_noise<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    choice((newline(), indent(), dedent(), select! { Token::Comment(_) => () }))
        .repeated()
        .ignored()
}

/// Skip block noise (newlines and comments only - not indent/dedent).
pub fn skip_block_noise<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    choice((newline(), select! { Token::Comment(_) => () }))
        .repeated()
        .ignored()
}

/// Skip noise between top-level blocks (newlines, comments, AND dedents).
/// DEDENTs appear between blocks when exiting nested indented blocks.
pub fn skip_toplevel_noise<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    choice((newline(), dedent(), select! { Token::Comment(_) => () }))
        .repeated()
        .ignored()
}

/// Skip comments only (not newlines).
#[allow(dead_code)]
pub fn skip_comments<'tokens, 'src: 'tokens>(
) -> impl Parser<'tokens, ParserInput<'tokens, 'src>, (), extra::Err<Rich<'tokens, Token<'src>, Span>>>
       + Clone {
    select! { Token::Comment(_) => () }.repeated().ignored()
}

/// Parse a description entry: `description: "..."`
pub fn description_entry<'tokens, 'src: 'tokens>() -> impl Parser<
    'tokens,
    ParserInput<'tokens, 'src>,
    Spanned<String>,
    extra::Err<Rich<'tokens, Token<'src>, Span>>,
> + Clone {
    just(Token::Description)
        .ignore_then(just(Token::Colon))
        .ignore_then(spanned_string())
}