cleaning up old API

Author: leogdion

Sources/SyntaxParser/SourceRange.swift

@@ -39,18 +39,18 @@ import Foundation
 /// - Refactoring tools modifying specific code regions
 ///
 /// Coordinates use 1-based indexing to match common editor conventions.
-internal struct SourceRange: Codable, Equatable {
+package struct SourceRange: Codable, Equatable {
   /// The line number where this syntax element begins (1-based).
-  internal let startRow: Int
+  package let startRow: Int
 
   /// The column number where this syntax element begins (1-based).
-  internal let startColumn: Int
+  package let startColumn: Int
 
   /// The line number where this syntax element ends (1-based).
-  internal let endRow: Int
+  package let endRow: Int
 
   /// The column number where this syntax element ends (1-based).
-  internal let endColumn: Int
+  package let endColumn: Int
 
   /// Creates a new SourceRange with the specified coordinates.
   ///
@@ -59,7 +59,7 @@ internal struct SourceRange: Codable, Equatable {
   ///   - startColumn: Starting column number (1-based)
   ///   - endRow: Ending line number (1-based)
   ///   - endColumn: Ending column number (1-based)
-  internal init(startRow: Int, startColumn: Int, endRow: Int, endColumn: Int) {
+  package init(startRow: Int, startColumn: Int, endRow: Int, endColumn: Int) {
     self.startRow = startRow
     self.startColumn = startColumn
     self.endRow = endRow

Sources/SyntaxParser/String.swift

@@ -40,28 +40,28 @@ import Foundation
 /// - Function declaration "name" property → StructureValue with identifier text
 /// - Function declaration "body" property → Reference to "CodeBlockSyntax"
 /// - Missing optional property → nil value with just the property name
-internal struct StructureProperty: Codable, Equatable {
+package struct StructureProperty: Codable, Equatable {
   /// The name of this structural property.
   /// Corresponds to SwiftSyntax property names like "name", "parameters", "body", etc.
-  internal let name: String
+  package let name: String
 
   /// The value of this property, if it contains terminal data.
   /// Present for tokens, literals, and other concrete values.
   /// Nil for missing optional properties.
-  internal let value: StructureValue?
+  package let value: StructureValue?
 
   /// Reference to another syntax node type, if this property contains a nested structure.
   /// Used when this property points to another syntax node rather than containing terminal data.
   /// Example: "body" property might reference "CodeBlockSyntax"
-  internal let ref: String?
+  package let ref: String?
 
   /// Creates a new StructureProperty with the specified components.
   ///
   /// - Parameters:
   ///   - name: The property name
   ///   - value: Terminal value data, if any
   ///   - ref: Reference to another syntax type, if any
-  internal init(name: String, value: StructureValue? = nil, ref: String? = nil) {
+  package init(name: String, value: StructureValue? = nil, ref: String? = nil) {
     self.name = name
     self.value = value
     self.ref = ref

Sources/SyntaxParser/StructureProperty.swift

@@ -40,22 +40,22 @@ import Foundation
 /// - Token value: text="let", kind="keyword(SwiftSyntax.Keyword.let)"
 /// - Type reference: text="VariableDeclSyntax", kind=nil
 /// - Literal value: text="42", kind="integerLiteral(42)"
-internal struct StructureValue: Codable, Equatable {
+package struct StructureValue: Codable, Equatable {
   /// The string representation of this value.
   /// Contains the actual text content or type name.
-  internal let text: String
+  package let text: String
 
   /// Optional kind information that provides additional context about the value type.
   /// Present for tokens to indicate their specific token kind (e.g., "keyword", "identifier").
   /// Nil for simple text values and type references.
-  internal let kind: String?
+  package let kind: String?
 
   /// Creates a new StructureValue with the specified content.
   ///
   /// - Parameters:
   ///   - text: The string representation of the value
   ///   - kind: Optional kind information for additional context
-  internal init(text: String, kind: String? = nil) {
+  package init(text: String, kind: String? = nil) {
     self.text = text
     self.kind = kind
   }

Sources/SyntaxParser/StructureValue.swift

@@ -64,7 +64,7 @@ import SwiftSyntax
  - `Token`: Token-specific metadata (kind, trivia)
  - `SourceRange`: Line/column location coordinates
  - `SyntaxType`: Semantic classification of syntax elements
- - `SyntaxResponse`: Container for final JSON output
+ - `SyntaxResponse`: Container for final JSON output (deprecated)
 
  ## Processing Pipeline
 
@@ -115,39 +115,71 @@ import SwiftSyntax
      }
      """
 
- let response = try SyntaxParser.parse(code: code)
- // response.syntaxJSON contains the flattened tree structure
+ let treeNodes = SyntaxParser.parse(code: code)
+ // treeNodes contains the array of TreeNode objects directly
  ```
 
  This module is primarily consumed by the `skit` command-line tool for
  converting Swift source code to JSON for external analysis and tooling.
  */
 
-/// Main entry point for parsing Swift source code into JSON representation.
+/// Main entry point for parsing Swift source code into TreeNode representation.
 ///
-/// SyntaxParser converts Swift source code into a structured JSON format that represents
-/// the Abstract Syntax Tree (AST). This is primarily used by the `skit` command-line tool
-/// to provide Swift code analysis for external tools and applications.
+/// SyntaxParser converts Swift source code into an array of TreeNode objects that represents
+/// the Abstract Syntax Tree (AST). This provides direct access to the parsed syntax structure
+/// for programmatic analysis and manipulation.
 ///
 /// The parser leverages Apple's SwiftSyntax framework to perform the actual parsing,
-/// then transforms the complex SwiftSyntax AST into a simplified, serializable format
-/// suitable for JSON output and console consumption.
+/// then transforms the complex SwiftSyntax AST into a simplified, flat structure
+/// suitable for direct consumption by Swift code.
 package enum SyntaxParser {
   // MARK: - Configuration Constants
 
   /// Option key to enable operator precedence folding during parsing.
   /// When enabled, expressions are reorganized according to Swift's operator precedence rules.
+  @available(*, deprecated, message: "Operator precedence folding is not supported in the new parse(code:) method")
   private static let fold = "fold"
 
   /// Option key to include missing/implicit tokens in the output.
   /// Useful for debugging or when you need to see all syntax elements including placeholders.
+  @available(*, deprecated, message: "Missing token display is not supported in the new parse(code:) method")
   private static let showMissing = "showmissing"
 
   /// Default filename used for source location tracking when no specific file is provided.
   private static let defaultFileName = ""
 
   // MARK: - Public Interface
 
+  /// Parses Swift source code and returns an array of TreeNode objects.
+  ///
+  /// This method performs the complete parsing pipeline:
+  /// 1. Parses Swift source code using SwiftSyntax
+  /// 2. Traverses the AST to extract structure and token information
+  /// 3. Returns the tree nodes directly without JSON serialization
+  ///
+  /// - Parameter code: Swift source code to parse
+  /// - Returns: Array of TreeNode objects representing the syntax tree
+  package static func parse(code: String) -> [TreeNode] {
+    // Parse the Swift source code into a SwiftSyntax AST
+    let sourceFile = Parser.parse(source: code)
+
+    // Use raw syntax tree without precedence folding for simplicity
+    let syntax = Syntax(sourceFile)
+
+    // Create visitor to traverse AST and extract structured information
+    let visitor = TokenVisitor(
+      locationConverter: SourceLocationConverter(
+        fileName: defaultFileName, tree: sourceFile),
+      showMissingTokens: false
+    )
+
+    // Traverse the syntax tree and build our simplified representation
+    _ = visitor.rewrite(syntax)
+
+    // Return the tree nodes directly
+    return visitor.tree
+  }
+
   /// Parses Swift source code and returns a JSON representation of its syntax tree.
   ///
   /// This method performs the complete parsing pipeline:
@@ -163,6 +195,7 @@ package enum SyntaxParser {
   ///     - "showmissing": Include missing/implicit tokens in output
   /// - Returns: SyntaxResponse containing the JSON representation
   /// - Throws: JSONEncoder errors if serialization fails
+  @available(*, deprecated, message: "Use parse(code:) instead for direct TreeNode access")
   package static func parse(code: String, options: [String] = []) throws -> SyntaxResponse {
     // Parse the Swift source code into a SwiftSyntax AST
     let sourceFile = Parser.parse(source: code)

Sources/SyntaxParser/SyntaxParser.swift

@@ -39,15 +39,18 @@ import Foundation
 /// The JSON contains a flat array of TreeNode objects representing the
 /// complete Swift syntax tree in a format suitable for external analysis
 /// tools, IDEs, and other applications that need to understand Swift code structure.
+@available(*, deprecated, message: "Use parse(code:) which returns [TreeNode] directly instead of JSON")
 package struct SyntaxResponse: Codable {
   /// JSON string representation of the parsed syntax tree.
   /// Contains a serialized array of TreeNode objects with their relationships,
   /// source locations, and structural information.
+  @available(*, deprecated, message: "Use parse(code:) which returns [TreeNode] directly instead of JSON")
   package let syntaxJSON: String
 
   /// Creates a new SyntaxResponse with the provided JSON data.
   ///
   /// - Parameter syntaxJSON: The JSON string representation of the syntax tree
+  @available(*, deprecated, message: "Use parse(code:) which returns [TreeNode] directly instead of JSON")
   package init(syntaxJSON: String) {
     self.syntaxJSON = syntaxJSON
   }

Sources/SyntaxParser/SyntaxResponse.swift

@@ -39,7 +39,7 @@ import Foundation
 ///
 /// The classification is based on the SwiftSyntax type hierarchy and groups
 /// related syntax elements into meaningful categories.
-internal enum SyntaxType: String, Codable, Equatable {
+package enum SyntaxType: String, Codable, Equatable {
   /// Declaration syntax elements.
   /// Includes: struct, class, enum, func, var, let, import, protocol, extension, etc.
   case decl

Sources/SyntaxParser/SyntaxType.swift

@@ -40,26 +40,26 @@ import Foundation
 /// newlines, comments, and other formatting elements that don't directly
 /// participate in the Swift language grammar but are important for
 /// code reconstruction and analysis.
-internal struct Token: Codable, Equatable {
+package struct Token: Codable, Equatable {
   /// The classification of this token (e.g., "keyword", "identifier", "integerLiteral").
   /// Corresponds to SwiftSyntax TokenKind descriptions.
-  internal let kind: String
+  package let kind: String
 
   /// Trivia that appears before this token.
   /// Includes whitespace, comments, and other non-semantic text preceding the token.
-  internal var leadingTrivia: String
+  package var leadingTrivia: String
 
   /// Trivia that appears after this token.
   /// Includes whitespace, comments, and other non-semantic text following the token.
-  internal var trailingTrivia: String
+  package var trailingTrivia: String
 
   /// Creates a new Token with the specified properties.
   ///
   /// - Parameters:
   ///   - kind: The token classification
   ///   - leadingTrivia: Text appearing before the token
   ///   - trailingTrivia: Text appearing after the token
-  internal init(kind: String, leadingTrivia: String, trailingTrivia: String) {
+  package init(kind: String, leadingTrivia: String, trailingTrivia: String) {
     self.kind = kind
     self.leadingTrivia = leadingTrivia
     self.trailingTrivia = trailingTrivia