@zxsylph/dbml-formatter 1.0.1

package/.agent/workflows/publish_to_npm.md

@@ -0,0 +1,50 @@
+---
+description: How to publish the package to NPM
+---
+
+# Publishing to NPM
+
+Follow these steps to publish your `dbml_formatter` tool to the NPM registry.
+
+## 1. Prepare the Package
+
+1.  **Check Package Name**: The name `dbml-extension` might be taken. You should check [npmjs.com](https://www.npmjs.com/) or change `"name"` in `package.json` to something unique (e.g., `@your-username/dbml-formatter` or `dbml-fmt-cli`).
+2.  **Update Version**: Ensure `"version"` in `package.json` is correct (e.g., `1.0.0` for initial release).
+3.  **Clean Dependencies**: Since we are using `ts-node` at runtime, ensuring `typescript` and `ts-node` are in `"dependencies"` (which they are) is correct for this setup.
+
+## 2. Authenticate
+
+Run the following command to log in to your NPM account:
+
+```bash
+npm login
+```
+
+## 3. Publish
+
+Run the publish command:
+
+```bash
+npm publish
+```
+
+If you are using a scoped name (like `@user/pkg`), use:
+
+```bash
+npm publish --access public
+```
+
+## 4. Usage After Publishing
+
+Once published, anyone can run your tool using `npx`:
+
+```bash
+npx [your-package-name] <file.dbml>
+```
+
+If you named it `dbml-extension`, they would run `npx dbml-extension <file>`.
+If you want the command to be `npx dbml_formatter`, you should name the package `dbml_formatter` (if available), OR users can run:
+
+```bash
+npx -p [your-package-name] dbml_formatter <file>
+```

package/bin/dbml_formatter.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+require('ts-node').register();
+require('../src/cli.ts');

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@zxsylph/dbml-formatter",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bin": {
+    "dbml_formatter": "./bin/dbml_formatter.js"
+  },
+  "dependencies": {
+    "@dbml/core": "^5.4.1",
+    "@types/node": "^25.0.8",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/sample.dbml

@@ -0,0 +1,21 @@
+// Table definition for users
+Table users {
+  id integer [primary key, increment] // Auto-incrementing ID
+  username varchar
+    email varchar [unique]
+  created_at timestamp
+}
+
+/*
+  Multi-line comment
+  about posts
+*/
+Table posts{
+id integer [primary key]
+  user_id integer
+title varchar
+body text [note: 'Content of the post']
+}
+
+// Reference link
+Ref: posts.user_id > users.id

package/sample_messy.dbml

@@ -0,0 +1,3 @@
+Table   messy{id int[pk]
+name varchar}
+Ref : messy.id>other.id

package/sample_messy2.dbml

@@ -0,0 +1,4 @@
+Table   messy{id int[pk]
+name varchar
+a_id int [Ref: > other.id, note: 'other.id']}
+Ref : messy.id>other.id

package/sample_messy3.dbml

@@ -0,0 +1,5 @@
+Table   messy{id int[pk]
+name varchar
+a_id int [Ref: > other.id, note: 'other.id']
+note: "table note"}
+Ref : messy.id>other.id

package/sample_messy4.dbml

@@ -0,0 +1,5 @@
+table   messy{id int[pk]
+name varchar
+a_id int [ref: > other.id, note: 'other.id']
+note: "table note"}
+Ref : messy.id>other.id

package/sample_messy5.dbml

@@ -0,0 +1,6 @@
+table   messy{id int[pk]
+name varchar
+a_id int [ref: > other.id, note: 'other.id']
+table_id int [note: 'link to table table']
+note: "table note"}
+Ref : messy.id>other.id

package/src/cli.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { format } from './formatter/formatter';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    console.error('Usage: dbml-fmt <file>');
+    process.exit(1);
+}
+
+const filePath = args[0];
+const absPath = path.resolve(process.cwd(), filePath);
+
+if (!fs.existsSync(absPath)) {
+    console.error(`File not found: ${absPath}`);
+    process.exit(1);
+}
+
+try {
+    const content = fs.readFileSync(absPath, 'utf-8');
+    const formatted = format(content);
+    console.log(formatted);
+} catch (error) {
+    console.error('Error formatting file:', error);
+    process.exit(1);
+}

package/src/experiment.ts

@@ -0,0 +1,21 @@
+import { importer, exporter } from '@dbml/core';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const samplePath = path.join(__dirname, '../sample.dbml');
+const content = fs.readFileSync(samplePath, 'utf-8');
+
+console.log('Original Content:');
+console.log(content);
+
+try {
+    const imported = importer.import(content, 'dbml');
+    console.log('Imported (Intermediate Model):');
+    // console.log(imported); // It might be large
+
+    const exported = exporter.export(imported, 'dbml');
+    console.log('Exported (Formatted Content):');
+    console.log(exported);
+} catch (err) {
+    console.error('Error:', err);
+}

package/src/formatter/formatter.ts

@@ -0,0 +1,558 @@
+import { Token, TokenType, tokenize } from './tokenizer';
+
+export interface FormatterOptions {
+    indentSize?: number;
+    useTabs?: boolean;
+}
+
+export function format(input: string, options: FormatterOptions = {}): string {
+    const rawTokens = tokenize(input);
+    const indentSize = options.indentSize || 2;
+    const indentChar = options.useTabs ? '\t' : ' ';
+    const oneIndent = indentChar.repeat(indentSize);
+
+    // Initial Pass: Identify Block Types and context
+    // Actually we can process linearly but when we hit `Table {`, we switch to "buffer mode".
+    
+    let output = '';
+    let indentLevel = 0;
+    
+    // Helper to get current indentation string
+    const getIndent = () => oneIndent.repeat(Math.max(0, indentLevel));
+
+    let i = 0;
+    while (i < rawTokens.length) {
+        let token = rawTokens[i];
+        
+        // --- Lookahead to detect start of Table block ---
+        if (token.type === TokenType.Symbol && token.value === '{') {
+             // Identify if this is a Table block
+             let isTable = false;
+             let backIndex = i - 1;
+             while(backIndex >= 0 && (rawTokens[backIndex].type === TokenType.Whitespace || rawTokens[backIndex].type === TokenType.Comment)) {
+                 backIndex--;
+             }
+             // Determine block keyword (heuristic search back)
+             let searchIndex = backIndex;
+             while (searchIndex >= 0) {
+                 const t = rawTokens[searchIndex];
+                 if (t.type === TokenType.Symbol && (t.value === '}' || t.value === '{')) break;
+                 if (t.type === TokenType.Word) {
+                     // Check case-insensitive
+                     if (t.value.toLowerCase() === 'table') {
+                         isTable = true;
+                         break;
+                     }
+                 }
+                 searchIndex--;
+             }
+
+             if (isTable) {
+                 // BUFFER MODE
+                 // 1. Flush/print the '{'
+                 // Should ensure space before '{'
+                 if (output.length > 0 && !output.endsWith(' ') && !output.endsWith('\n')) {
+                     output += ' ';
+                 }
+                 output += '{';
+                 output += '\n';
+                 indentLevel++;
+                 i++;
+                 
+                 // 2. Collect tokens inside `{ ... }`
+                 const buffer: Token[] = [];
+                 let depth = 1;
+                 while (i < rawTokens.length) {
+                     const t = rawTokens[i];
+                     if (t.type === TokenType.Symbol && t.value === '{') depth++;
+                     if (t.type === TokenType.Symbol && t.value === '}') {
+                         depth--;
+                         if (depth === 0) break; // Found end of table
+                     }
+                     buffer.push(t);
+                     i++;
+                 }
+                 // Now `rawTokens[i]` is the closing `}` (or we ran out)
+                 
+                 // 3. Process the buffer
+                 //    a. Separate into logical "lines" (statements)
+                 //    b. Identify Table Note
+                 //    c. Identify Field Lines
+                 
+                 let tableNoteTokens: Token[] = [];
+                 const otherLinesGroups: Token[][] = [];
+                 
+                 // Split buffer into "line groups".
+                 // A line group is a set of tokens ending with newline(s).
+                 let currentGroup: Token[] = [];
+                 
+                 for (let k = 0; k < buffer.length; k++) {
+                     const t = buffer[k];
+                     
+                     // We blindly optimize: split on newline unless inside `nested` brackets.
+                     currentGroup.push(t);
+                     
+                     if (t.type === TokenType.Whitespace && t.value.includes('\n')) {
+                         // Check depth
+                         let brDepth = 0;
+                         for (const gt of currentGroup) {
+                             if (gt.type === TokenType.Symbol && gt.value === '[') brDepth++;
+                             if (gt.type === TokenType.Symbol && gt.value === ']') brDepth--;
+                             if (gt.type === TokenType.Symbol && gt.value === '{') brDepth++;
+                             if (gt.type === TokenType.Symbol && gt.value === '}') brDepth--;
+                         }
+                         
+                         if (brDepth === 0) {
+                             // End of logical line
+                             // Check if it is a Note
+                             const meaningful = currentGroup.filter(x => x.type !== TokenType.Whitespace && x.type !== TokenType.Comment);
+                             
+                             let isNote = false;
+                             if (meaningful.length >= 3) {
+                                  if (meaningful[0].type === TokenType.Word && meaningful[0].value.toLowerCase() === 'note' &&
+                                      meaningful[1].type === TokenType.Symbol && meaningful[1].value === ':') {
+                                      isNote = true;
+                                  }
+                             }
+                             
+                             if (isNote) {
+                                  // This is the table note
+                                  tableNoteTokens = currentGroup;
+                             } else {
+                                  otherLinesGroups.push(currentGroup);
+                             }
+                             currentGroup = [];
+                         }
+                     }
+                 }
+                 if (currentGroup.length > 0) {
+                     // Check remaining
+                     const meaningful = currentGroup.filter(x => x.type !== TokenType.Whitespace && x.type !== TokenType.Comment);
+                     
+                     let isNote = false;
+                     if (meaningful.length >= 3) {
+                          if (meaningful[0].type === TokenType.Word && meaningful[0].value.toLowerCase() === 'note' &&
+                              meaningful[1].type === TokenType.Symbol && meaningful[1].value === ':') {
+                              isNote = true;
+                          }
+                     }
+                     
+                     if (isNote) {
+                         tableNoteTokens = currentGroup;
+                     } else {
+                         otherLinesGroups.push(currentGroup);
+                     }
+                 }
+                 
+                 // 4. Print Table Note first (if exists)
+                 if (tableNoteTokens.length > 0) {
+                     // Ensure tokens end with newline if they don't?
+                     // Usually they contain the newline token.
+                     // But if it was the last line of buffer (no newline), we must add one.
+                     
+                     output += processTokens(tableNoteTokens, indentLevel, indentChar, indentSize, false); 
+                     
+                     // Rule: after table note add one empty line
+                     // So we want `output` to end with `\n\n`.
+                     if (output.endsWith('\n\n')) {
+                         // already good
+                     } else if (output.endsWith('\n')) {
+                         output += '\n';
+                     } else {
+                         output += '\n\n';
+                     }
+                 }
+                 
+                 // 5. Print other lines (Process Fields)
+                 for (let lgIdx = 0; lgIdx < otherLinesGroups.length; lgIdx++) {
+                     const lineTokens = otherLinesGroups[lgIdx];
+                     // Check for Field Settings `[...]` reordering
+                     // Find `[` ... `]`
+                     let openBracketIdx = -1;
+                     let closeBracketIdx = -1;
+                     
+                     for(let idx=0; idx<lineTokens.length; idx++) {
+                         if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === '[') openBracketIdx = idx;
+                         if (lineTokens[idx].type === TokenType.Symbol && lineTokens[idx].value === ']') closeBracketIdx = idx;
+                     }
+                     
+                     if (openBracketIdx !== -1 && closeBracketIdx !== -1 && closeBracketIdx > openBracketIdx) {
+                         // Extract tokens inside
+                         const inside = lineTokens.slice(openBracketIdx + 1, closeBracketIdx);
+                         // Check if multiline
+                         const settings: Token[][] = [];
+                         let currentSetting: Token[] = [];
+                         for(const t of inside) {
+                             if (t.type === TokenType.Symbol && t.value === ',') {
+                                 settings.push(currentSetting);
+                                 currentSetting = [];
+                             } else {
+                                 currentSetting.push(t);
+                             }
+                         }
+                         if (currentSetting.length > 0) settings.push(currentSetting);
+                         
+                         // Identify "note" setting
+                         let noteIndex = -1;
+                         for(let s=0; s<settings.length; s++) {
+                             const sMeaningful = settings[s].filter(x => x.type !== TokenType.Whitespace && x.type !== TokenType.Comment);
+                             if (sMeaningful.length > 0 && sMeaningful[0].type === TokenType.Word && sMeaningful[0].value.toLowerCase() === 'note') {
+                                 noteIndex = s;
+                                 break;
+                             }
+                         }
+                         
+                         if (noteIndex > 0) { // If found and NOT already first
+                             // Move to front
+                             const noteSetting = settings.splice(noteIndex, 1)[0];
+                             settings.unshift(noteSetting);
+                             
+                             // Reconstruct lineTokens
+                             const newInside: Token[] = [];
+                             for(let s=0; s<settings.length; s++) {
+                                 newInside.push(...settings[s]);
+                                 if (s < settings.length - 1) {
+                                     newInside.push({ type: TokenType.Symbol, value: ',', line: 0, column: 0 });
+                                 }
+                             }
+                             
+                             // Replace in lineTokens
+                             lineTokens.splice(openBracketIdx + 1, closeBracketIdx - openBracketIdx - 1, ...newInside);
+                         }
+                     }
+                     
+                     // 6. Apply "Quote Data Types" logic
+                    let wordCount = 0;
+                    for (const t of lineTokens) {
+                         // Only count words before `[`?
+                         if (t.type === TokenType.Symbol && t.value === '[') break;
+                         if (t.type === TokenType.Word) {
+                             wordCount++;
+                             if (wordCount === 2) {
+                                 // Quote this token!
+                                 t.value = `"${t.value}"`; 
+                                 // Note: we are modifying the token object directly in the buffer.
+                             }
+                         }
+                         if (t.type === TokenType.String && wordCount < 2) { 
+                             // Strings count as words/tokens for position?
+                             // Example `name "varchar"` -> "varchar" IS the string.
+                             wordCount++; 
+                         }
+                    }
+
+                    // Ensure previous line enforced newline if missing?
+                    // processTokens appends tokens. If tokens lack newline, it might merge?
+                    // `lineTokens` usually comes from `currentGroup` which ended with newline token (except last one).
+                    // If last group lacks newline, and we print next group...
+                    
+                    // Check if output buffer needs separation?
+                    // processTokens logic respects local newlines inside `lineTokens`.
+                    // But if `lineTokens` (last group) didn't have newline, we append.
+                    
+                    output += processTokens(lineTokens, indentLevel, indentChar, indentSize, true);
+                    
+                    // Heuristic: If we just printed a line group, and it didn't generate a newline at end,
+                    // AND there is another group coming, insert newline?
+                    // But `processTokens` output might end with proper indent? No.
+                    
+                    // Let's check `output`.
+                    if (lgIdx < otherLinesGroups.length - 1) {
+                        if (!output.endsWith('\n')) {
+                             // This implies the group didn't end with newline token.
+                             // Force it.
+                             output += '\n';
+                        }
+                    }
+                 }
+                 
+                 // End block
+                 indentLevel--; 
+                 if (!output.endsWith('\n')) output += '\n';
+                 output += getIndent() + '}'; 
+                 
+                 // Rule: after table close } add on empty line
+                 output += '\n'; // This ensures at least one newline after `}`
+                 // To ensure "one empty line", we need two newlines total?
+                 // `output` ends with `}\n`.
+                 // If we add `\n`, it becomes `}\n\n`.
+                 output += '\n'; 
+                 
+                 if (i < rawTokens.length && rawTokens[i].type === TokenType.Symbol && rawTokens[i].value === '}') {
+                     i++;
+                 }
+
+                 continue; // Continue outer loop
+             }
+        }
+        
+    // Linear Loop Fallback Logic needs to use `processTokens` properly or duplicate spacing logic
+    // Actually, the issue is that in the fallback loop:
+    // `output += processTokens([token], ...)` 
+    // `processTokens` checks `localOutput` (which is empty for that call) to decide spacing.
+    // It doesn't know about `output`'s tail.
+    
+    // Fix: We must pass `output` context to `processTokens`, or handle spacing BEFORE calling `processTokens`.
+    
+    // Easier Fix: Centralize "appendToken" logic.
+    
+    // Let's rewrite the main loop to handle spacing explicitly before appending.
+    
+    // But `processTokens` handles a list.
+    
+    // Let's modify `processTokens` to accept `previousChar` or `needsSpaceCheck`?
+    
+    // Actually, `processTokens` is used for buffered content (Table block).
+    // The main loop handles non-buffered content.
+    
+    // The previous implementation was:
+    /*
+        if (output.length > 0) {
+            let needsSpace = true;
+            // ... checks ...
+            if (needsSpace) output += ' ';
+        }
+        output += token.value;
+    */
+    
+    // In the new implementation:
+    /*
+        const singleTokenList = [token];
+        output += processTokens(singleTokenList, ...);
+    */
+   
+    // `processTokens` internal logic:
+    // `if (localOutput.length > 0) { check space }`
+    // Since `singleTokenList` has 1 item, `localOutput` is empty initially, so NO SPACE is added.
+    
+    // We need to restore the spacing logic in the main loop for the fallback case.
+    // AND ensuring `processTokens` handles its internal list correctly.
+    
+    // Let's fix the Main Loop Fallback first.
+
+        // --- Fallback: Standard Linear Processing for non-Table content ---
+        
+        // Handle whitespace first
+        if (token.type === TokenType.Whitespace) {
+            const newlines = (token.value.match(/\n/g) || []).length;
+            if (newlines > 0) {
+                 const toPrint = Math.min(newlines, 2); 
+                 if (!output.endsWith('\n')) {
+                    output += '\n'.repeat(toPrint);
+                 } else {
+                    if (toPrint > 1 && !output.endsWith('\n\n')) {
+                        output += '\n';
+                    }
+                 }
+            }
+            i++;
+            continue;
+        }
+
+        // Apply spacing based on GLOBAL `output`
+        if (output.endsWith('\n')) {
+             if (token.value !== '}') {
+                 output += getIndent();
+             }
+        } else if (output.length > 0) {
+            let needsSpace = true;
+            const lastChar = output[output.length - 1];
+            if (lastChar === ' ' || lastChar === '\n' || lastChar === '(' || lastChar === '[' || lastChar === '.') {
+                needsSpace = false;
+            }
+            if (token.type === TokenType.Symbol) {
+                 if (token.value === ',' || token.value === ']' || token.value === ')' || token.value === '.' || token.value === ':') {
+                     needsSpace = false;
+                 }
+                 // Ref: > or < logic?
+            }
+            if (needsSpace) output += ' ';
+        }
+        
+        // Output with Keyword Normalization
+        switch (token.type) {
+            case TokenType.Word:
+                // Global Keyword PascalCase
+                // table -> Table
+                if (token.value.toLowerCase() === 'table') {
+                    token.value = 'Table';
+                }
+                
+                // ref -> Ref
+                if (token.value.toLowerCase() === 'ref') {
+                    token.value = 'Ref';
+                }
+                
+                // note -> Note (if followed by colon?)
+                if (token.value.toLowerCase() === 'note') {
+                     // Check next token for `:`
+                     let nextIdx = i + 1;
+                     while(nextIdx < rawTokens.length && (rawTokens[nextIdx].type === TokenType.Whitespace || rawTokens[nextIdx].type === TokenType.Comment)) {
+                         nextIdx++;
+                     }
+                     if (nextIdx < rawTokens.length && rawTokens[nextIdx].type === TokenType.Symbol && rawTokens[nextIdx].value === ':') {
+                         token.value = 'Note';
+                     }
+                }
+                
+                output += token.value;
+                break;
+                
+            case TokenType.String:
+                let val = token.value;
+                if (val.startsWith("'") && !val.startsWith("'''")) {
+                    const content = val.slice(1, -1);
+                    const escaped = content.replace(/"/g, '\\"');
+                    val = `"${escaped}"`;
+                }
+                output += val;
+                break;
+            default:
+                output += token.value;
+                break;
+        }
+        
+        i++;
+    }
+
+    return output.trim() + '\n';
+}
+
+// ... helper functions ...
+
+function processTokens(
+    tokens: Token[], 
+    baseIndentLevel: number, 
+    indentChar: string, 
+    indentSize: number, 
+    isInsideTable: boolean
+): string {
+    
+    let localOutput = '';
+    let currentIndentLevel = baseIndentLevel;
+    const oneIndent = indentChar.repeat(indentSize);
+    const getLocalIndent = () => oneIndent.repeat(Math.max(0, currentIndentLevel));
+    
+    // ... multiline stack and checkArrayMultiline ...
+     const checkArrayMultiline = (startIdx: number): boolean => {
+         let depth = 1;
+         let hasComma = false;
+         for (let k = startIdx + 1; k < tokens.length; k++) {
+             if (tokens[k].type === TokenType.Symbol && tokens[k].value === '[') depth++;
+             if (tokens[k].type === TokenType.Symbol && tokens[k].value === ']') depth--;
+             if (depth === 1 && tokens[k].type === TokenType.Symbol && tokens[k].value === ',') hasComma = true;
+             if (depth === 0) return hasComma;
+         }
+         return false;
+    };
+    
+    const multilineArrayStack: boolean[] = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        
+        // Whitespace handling
+        if (token.type === TokenType.Whitespace) {
+            const newlines = (token.value.match(/\n/g) || []).length;
+            if (newlines > 0) {
+                 const toPrint = Math.min(newlines, 2); 
+                 if (!localOutput.endsWith('\n')) {
+                    localOutput += '\n'.repeat(toPrint);
+                 } else {
+                    if (toPrint > 1 && !localOutput.endsWith('\n\n')) {
+                        localOutput += '\n';
+                    }
+                 }
+            }
+            continue;
+        }
+
+        // Corrected Spacing/Indent Logic for processTokens:
+        if (localOutput.length === 0 || localOutput.endsWith('\n')) {
+             if (token.value !== '}') {
+                 localOutput += getLocalIndent();
+             }
+        } else {
+             // Not start of line
+            let needsSpace = true;
+            const lastChar = localOutput[localOutput.length - 1];
+             if (lastChar === ' ' || lastChar === '\n' || lastChar === '(' || lastChar === '[' || lastChar === '.') {
+                needsSpace = false;
+            }
+            if (token.type === TokenType.Symbol) {
+                 if (token.value === ',' || token.value === ']' || token.value === ')' || token.value === '.' || token.value === ':') {
+                     needsSpace = false;
+                 }
+            }
+            if (needsSpace) localOutput += ' ';
+        }
+
+        switch (token.type) {
+             case TokenType.Symbol:
+                 if (token.value === '{') {
+                      localOutput += '{\n';
+                      currentIndentLevel++;
+                 } else if (token.value === '}') {
+                      if (!localOutput.endsWith('\n')) localOutput += '\n';
+                      currentIndentLevel--;
+                      localOutput += getLocalIndent() + '}';
+                 } else if (token.value === '[') {
+                      const isMultiline = checkArrayMultiline(i);
+                      multilineArrayStack.push(isMultiline);
+                      localOutput += '[';
+                      if (isMultiline) {
+                          localOutput += '\n';
+                          currentIndentLevel++;
+                      }
+                 } else if (token.value === ']') {
+                      const isMultiline = multilineArrayStack.pop();
+                      if (isMultiline) {
+                          if (!localOutput.endsWith('\n')) localOutput += '\n';
+                          currentIndentLevel--;
+                          if (localOutput.endsWith('\n')) localOutput += getLocalIndent();
+                      }
+                      localOutput += ']';
+                 } else if (token.value === ',') {
+                      localOutput += ',';
+                      const currentMultiline = multilineArrayStack.length > 0 && multilineArrayStack[multilineArrayStack.length - 1];
+                      if (currentMultiline) localOutput += '\n';
+                 } else {
+                      localOutput += token.value;
+                 }
+                 break;
+             
+             case TokenType.Word:
+                  // Handle keyword PascalCase in buffer
+                  if (token.value.toLowerCase() === 'table') token.value = 'Table';
+                  if (token.value.toLowerCase() === 'ref') token.value = 'Ref';
+                  if (token.value.toLowerCase() === 'note') {
+                       // Peek locally inside tokens list
+                        let nextIdx = i + 1;
+                        while(nextIdx < tokens.length && (tokens[nextIdx].type === TokenType.Whitespace || tokens[nextIdx].type === TokenType.Comment)) {
+                            nextIdx++;
+                        }
+                        if (nextIdx < tokens.length && tokens[nextIdx].type === TokenType.Symbol && tokens[nextIdx].value === ':') {
+                            token.value = 'Note';
+                        }
+                  }
+                  localOutput += token.value;
+                  break;
+
+             case TokenType.String:
+                let val = token.value;
+                if (val.startsWith("'") && !val.startsWith("'''")) {
+                    const content = val.slice(1, -1);
+                    const escaped = content.replace(/"/g, '\\"');
+                    val = `"${escaped}"`;
+                }
+                localOutput += val;
+                break;
+                
+             default:
+                localOutput += token.value;
+                break;
+        }
+    }
+    
+    return localOutput;
+}

package/src/formatter/tokenizer.ts

@@ -0,0 +1,222 @@
+export enum TokenType {
+    Whitespace,
+    Comment,
+    String,
+    Symbol,
+    Word,
+    Unknown
+}
+
+export interface Token {
+    type: TokenType;
+    value: string;
+    line: number;
+    column: number;
+}
+
+export function tokenize(input: string): Token[] {
+    const tokens: Token[] = [];
+    let current = 0;
+    let line = 1;
+    let column = 1;
+
+    while (current < input.length) {
+        let char = input[current];
+
+        // Handle Whitespace
+        if (/\s/.test(char)) {
+            let value = '';
+            const startLine = line;
+            const startColumn = column;
+
+            while (current < input.length && /\s/.test(input[current])) {
+                if (input[current] === '\n') {
+                    line++;
+                    column = 1;
+                } else {
+                    column++;
+                }
+                value += input[current];
+                current++;
+            }
+            tokens.push({ type: TokenType.Whitespace, value, line: startLine, column: startColumn });
+            continue;
+        }
+
+        // Handle Comments
+        if (char === '/' && input[current + 1] === '/') {
+            let value = '';
+            const startLine = line;
+            const startColumn = column;
+            
+            while (current < input.length && input[current] !== '\n') {
+                value += input[current];
+                current++;
+                column++;
+            }
+            tokens.push({ type: TokenType.Comment, value, line: startLine, column: startColumn });
+            continue;
+        }
+
+        if (char === '/' && input[current + 1] === '*') {
+            let value = '';
+            const startLine = line;
+            const startColumn = column;
+
+            value += '/*';
+            current += 2;
+            column += 2;
+
+            while (current < input.length) {
+                if (input[current] === '*' && input[current + 1] === '/') {
+                    value += '*/';
+                    current += 2;
+                    column += 2;
+                    break;
+                }
+                if (input[current] === '\n') {
+                    line++;
+                    column = 1;
+                } else {
+                    column++;
+                }
+                value += input[current];
+                current++;
+            }
+            tokens.push({ type: TokenType.Comment, value, line: startLine, column: startColumn });
+            continue;
+        }
+
+        // Handle Strings
+        // Triple quote '''
+        if (char === '\'' && input[current + 1] === '\'' && input[current + 2] === '\'') {
+             let value = "'''";
+             const startLine = line;
+             const startColumn = column;
+             current += 3;
+             column += 3;
+
+             while (current < input.length) {
+                if (input[current] === '\'' && input[current + 1] === '\'' && input[current + 2] === '\'') {
+                    value += "'''";
+                    current += 3;
+                    column += 3;
+                    break;
+                }
+                if (input[current] === '\n') {
+                    line++;
+                    column = 1;
+                } else {
+                    column++;
+                }
+                value += input[current];
+                current++;
+             }
+             tokens.push({ type: TokenType.String, value, line: startLine, column: startColumn });
+             continue;
+        }
+
+        // Single quote '
+        if (char === '\'') {
+            let value = "'";
+            const startLine = line;
+            const startColumn = column;
+            current++;
+            column++;
+
+            while (current < input.length) {
+                // Escape sequence \' handling could be added here if needed, but for now simple check
+                if (input[current] === '\\' && input[current + 1] === '\'') {
+                    value += "\\'";
+                    current += 2;
+                    column += 2;
+                    continue;
+                }
+
+                if (input[current] === '\'') {
+                    value += "'";
+                    current++;
+                    column++;
+                    break;
+                }
+                if (input[current] === '\n') {
+                    line++;
+                    column = 1;
+                } else {
+                    column++;
+                }
+                value += input[current];
+                current++;
+            }
+            tokens.push({ type: TokenType.String, value, line: startLine, column: startColumn });
+            continue;
+        }
+
+        // Double quote "
+        if (char === '"') {
+            let value = '"';
+            const startLine = line;
+            const startColumn = column;
+            current++;
+            column++;
+
+            while (current < input.length) {
+                 if (input[current] === '\\' && input[current + 1] === '"') {
+                    value += '\\"';
+                    current += 2;
+                    column += 2;
+                    continue;
+                }
+
+                if (input[current] === '"') {
+                    value += '"';
+                    current++;
+                    column++;
+                    break;
+                }
+                if (input[current] === '\n') {
+                    line++;
+                    column = 1;
+                } else {
+                    column++;
+                }
+                value += input[current];
+                current++;
+            }
+            tokens.push({ type: TokenType.String, value, line: startLine, column: startColumn });
+            continue;
+        }
+
+
+        // Handle Symbols
+        if (/[\{\}\[\]\(\),:>.\-<\\]/.test(char)) {
+            tokens.push({ type: TokenType.Symbol, value: char, line, column });
+            current++;
+            column++;
+            continue;
+        }
+
+        // Handle Words (Identifiers, Keywords, Numbers, etc.)
+        // We accept mostly anything that isn't whitespace or special symbols
+        if (/[a-zA-Z0-9_]/.test(char)) {
+             let value = '';
+             const startLine = line;
+             const startColumn = column;
+             
+             while (current < input.length && /[a-zA-Z0-9_]/.test(input[current])) {
+                 value += input[current];
+                 current++;
+                 column++;
+             }
+             tokens.push({ type: TokenType.Word, value, line: startLine, column: startColumn });
+             continue;
+        }
+
+        // Fallback or Unknown
+        tokens.push({ type: TokenType.Unknown, value: char, line, column });
+        current++;
+        column++;
+    }
+
+    return tokens;
+}

package/src/test_formatter.ts

@@ -0,0 +1,13 @@
+import { format } from './formatter/formatter';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const samplePath = path.join(__dirname, '../sample.dbml');
+const content = fs.readFileSync(samplePath, 'utf-8');
+
+const formatted = format(content);
+
+console.log('--- Original ---');
+console.log(content);
+console.log('--- Formatted ---');
+console.log(formatted);

package/src/test_tokenizer.ts

@@ -0,0 +1,14 @@
+import { tokenize, TokenType } from './formatter/tokenizer';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const samplePath = path.join(__dirname, '../sample.dbml');
+const content = fs.readFileSync(samplePath, 'utf-8');
+
+const tokens = tokenize(content);
+
+console.log('Tokens:');
+tokens.forEach(t => {
+    let typeName = TokenType[t.type];
+    console.log(`[${typeName}] ${JSON.stringify(t.value)}`);
+});

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true
+  }
+}