@agentica/core 0.32.7 → 0.32.8

package/src/utils/JsonUtil.spec.ts

@@ -2,103 +2,191 @@ import { JsonUtil } from "./JsonUtil";
 
 describe("JsonUtil", () => {
   describe("parse", () => {
-    it("should handle string that starts with '{}'", () => {
-      const jsonString = '{}{"name": "test", "value": 42}';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({ name: "test", value: 42 });
-    });
+    
+    describe("Normal Operations", () => {
+      it("should parse standard valid JSON", () => {
+        const jsonString = '{"normal": "json"}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ normal: "json" });
+      });
 
-    it("should handle array with '{}' prefix", () => {
-      const jsonString = '{}[1, 2, 3, "test"]';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual([1, 2, 3, "test"]);
-    });
+      it("should handle object with '{}' prefix", () => {
+        const jsonString = '{}{"name": "test", "value": 42}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ name: "test", value: 42 });
+      });
 
-    it("should handle nested object with '{}' prefix", () => {
-      const jsonString = '{}{"user": {"id": 1, "name": "John"}}';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({
-        user: { id: 1, name: "John" }
+      it("should handle array with '{}' prefix", () => {
+        const jsonString = '{}[1, 2, 3, "test"]';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual([1, 2, 3, "test"]);
       });
-    });
 
-    it("should handle primitive values with '{}' prefix", () => {
-      expect(JsonUtil.parse('{}42')).toBe(42);
-      expect(JsonUtil.parse('{}"hello"')).toBe("hello");
-      expect(JsonUtil.parse('{}true')).toBe(true);
-      expect(JsonUtil.parse('{}null')).toBeNull();
-    });
+      it("should handle primitive values with '{}' prefix", () => {
+        expect(JsonUtil.parse('{}42')).toBe(42);
+        expect(JsonUtil.parse('{}"hello"')).toBe("hello");
+        expect(JsonUtil.parse('{}true')).toBe(true);
+        expect(JsonUtil.parse('{}null')).toBeNull();
+      });
 
-    it("should not modify string that doesn't start with '{}'", () => {
-      const jsonString = '{"normal": "json"}';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({ normal: "json" });
-    });
+      it("should remove trailing comma in object", () => {
+        const jsonString = '{"name": "test", "value": 42,}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ name: "test", value: 42 });
+      });
 
-    // 마지막 괄호 누락 보정 테스트 (예상 기능)
-    it("should handle missing closing brace in object", () => {
-      const jsonString = '{"name": "test", "value": 42';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({ name: "test", value: 42 });
-    });
+      it("should remove trailing comma in array", () => {
+        const jsonString = '[1, 2, 3, "test",]';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual([1, 2, 3, "test"]);
+      });
 
-    it("should handle missing closing bracket in array", () => {
-      const jsonString = '[1, 2, 3, "test"';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual([1, 2, 3, "test"]);
-    });
+      it("should add missing closing brace in object", () => {
+        const jsonString = '{"name": "test", "value": 42';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ name: "test", value: 42 });
+      });
 
-    it("should handle nested object with missing closing brace", () => {
-      const jsonString = '{"user": {"id": 1, "name": "John"}';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({
-        user: { id: 1, name: "John" }
+      it("should add missing closing bracket in array", () => {
+        const jsonString = '[1, 2, 3, "test"';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual([1, 2, 3, "test"]);
       });
     });
 
-    it("should handle complex nested structure with missing closing brace", () => {
-      const jsonString = '{"users": [{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}], "count": 2';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({
-        users: [
-          { id: 1, name: "John" },
-          { id: 2, name: "Jane" }
-        ],
-        count: 2
+    describe("Combined Features", () => {
+      it("should handle '{}' prefix and missing closing brace together", () => {
+        const jsonString = '{}{"name": "test", "value": 42';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ name: "test", value: 42 });
       });
-    });
 
-    it("should handle both '{}' prefix and missing closing brace", () => {
-      const jsonString = '{}{"name": "test", "value": 42';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual({ name: "test", value: 42 });
-    });
+      it("should handle '{}' prefix and missing closing bracket together", () => {
+        const jsonString = '{}[1, 2, 3, "test"';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual([1, 2, 3, "test"]);
+      });
 
-    it("should handle both '{}' prefix and missing closing bracket in array", () => {
-      const jsonString = '{}[1, 2, 3, "test"';
-      const result = JsonUtil.parse(jsonString);
-      
-      expect(result).toEqual([1, 2, 3, "test"]);
-    });
+      it("should handle trailing comma in nested objects", () => {
+        const jsonString = '{"user": {"id": 1, "name": "John",}, "active": true,}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          user: { id: 1, name: "John" },
+          active: true
+        });
+      });
+
+      it("should handle missing closing brace in nested objects", () => {
+        const jsonString = '{"user": {"id": 1, "name": "John"}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          user: { id: 1, name: "John" }
+        });
+      });
 
-    // 에러 케이스 (보정할 수 없는 경우)
-    it("should throw error for completely invalid JSON", () => {
-      const invalidJson = '{invalid: json without quotes}';
-      
-      expect(() => JsonUtil.parse(invalidJson)).toThrow();
+      it("should handle missing closing brace in complex nested structure", () => {
+        const jsonString = '{"users": [{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}], "count": 2';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          users: [
+            { id: 1, name: "John" },
+            { id: 2, name: "Jane" }
+          ],
+          count: 2
+        });
+      });
+
+      it("should apply all correction features together", () => {
+        const jsonString = '{}{"name": "test", "items": [1, 2, 3,], "user": {"id": 1, "name": "John",}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          name: "test",
+          items: [1, 2, 3],
+          user: { id: 1, name: "John" }
+        });
+      });
+
+      it("should handle all issues simultaneously in complex nested structure", () => {
+        const jsonString = '{}{"data": {"users": [{"id": 1, "name": "John",}, {"id": 2, "name": "Jane",}], "meta": {"total": 2, "page": 1,}}, "status": "ok",';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          data: {
+            users: [
+              { id: 1, name: "John" },
+              { id: 2, name: "Jane" }
+            ],
+            meta: { total: 2, page: 1 }
+          },
+          status: "ok"
+        });
+      });
     });
 
-    it("should throw error for empty string", () => {
-      expect(() => JsonUtil.parse("")).toThrow();
+    describe("Edge Cases", () => {
+      it("should handle empty object with '{}' prefix", () => {
+        const jsonString = '{}{}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({});
+      });
+
+      it("should handle empty array with '{}' prefix", () => {
+        const jsonString = '{}[]';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual([]);
+      });
+
+      it("should handle nested object with '{}' prefix", () => {
+        const jsonString = '{}{"user": {"id": 1, "name": "John"}}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          user: { id: 1, name: "John" }
+        });
+      });
+
+      it("should handle multiple trailing commas", () => {
+        const jsonString = '{"items": [1, 2, 3,,,], "count": 3,,,}';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({
+          items: [1, 2, 3],
+          count: 3
+        });
+      });
+
+      it("should handle JSON with whitespace and formatting issues", () => {
+        const jsonString = '{} { "name" : "test" , "value" : 42 , } ';
+        const result = JsonUtil.parse(jsonString);
+        
+        expect(result).toEqual({ name: "test", value: 42 });
+      });
+
+      it("should throw error for completely invalid JSON", () => {
+        const invalidJson = '{invalid: json without quotes}';
+        
+        expect(() => JsonUtil.parse(invalidJson)).toThrow();
+      });
+
+      it("should throw error for empty string", () => {
+        expect(() => JsonUtil.parse("")).toThrow();
+      });
     });
+
   });
 });

package/src/utils/JsonUtil.ts

@@ -1,150 +1,14 @@
+import { addMissingBraces, removeEmptyObjectPrefix, removeTrailingCommas } from "es-jsonkit";
+
 export const JsonUtil = {
   parse,
 };
 
 function parse(str: string) {
-  const corrected = pipe(stripFirstBrace, correctMissingLastBrace)(str);
+  const corrected = pipe(removeEmptyObjectPrefix, addMissingBraces, removeTrailingCommas)(str);
+  console.log(corrected);
   return JSON.parse(corrected);
 }
 
 const pipe = (...fns: ((str: string) => string)[]) => (str: string) => fns.reduce((acc, fn) => fn(acc), str);
 
-function stripFirstBrace(str: string) {
-  if(RegExp("^{}.").test(str) === true) {
-    return str.substring(2);
-  }
-  return str;
-}
-
-export function correctMissingLastBrace(input: string): string {
-  const initial: ParseState = { s: "OUT", stack: [], line: 1, col: 0, edits: [] };
-
-  const scanned = Array.from(input).reduce<ParseState>((ps, ch, i) => {
-    const updated = ch === "\n"
-      ? { ...ps, line: ps.line + 1, col: 0 }
-      : { ...ps, col: ps.col + 1 };
-
-    const tok = categorize(ch);
-    const trans = (table[updated.s] as Record<Token, Transition>)?.[tok];
-    return trans ? trans(updated, ch, i) : updated;
-  }, initial);
-
-  // Return original string if string is not closed (do not modify)
-  if (scanned.s !== "OUT") return input;
-
-  // Insert closing braces at the end for remaining open braces (LIFO)
-  const withTail = scanned.stack.length === 0
-    ? scanned
-    : ((): ParseState => {
-        const closers = scanned.stack.slice().reverse().map(e => closeOf[e.type]).join("");
-        return {
-          ...scanned,
-          edits: [...scanned.edits, { op: "insert", index: input.length, text: closers }],
-          stack: [],
-        };
-      })();
-
-  return applyEditsImmutable(input, withTail.edits);
-}
-
-// Apply edits immutably
-function applyEditsImmutable(src: string, edits: ReadonlyArray<Edit>): string {
-  const sorted = [...edits].sort((a, b) => a.index - b.index);
-
-  type Build = { out: string; cursor: number };
-  const built = sorted.reduce<Build>((acc, e) => {
-    const prefix = src.slice(acc.cursor, e.index);
-    const acc1 = { out: acc.out + prefix, cursor: e.index };
-    return e.op === "delete"
-      ? { out: acc1.out,          cursor: acc1.cursor + 1 }
-      : e.op === "replace"
-      ? { out: acc1.out + e.text, cursor: acc1.cursor + 1 }
-      : /* insert */ { out: acc1.out + e.text, cursor: acc1.cursor };
-  }, { out: "", cursor: 0 });
-
-  return built.out + src.slice(built.cursor);
-}
-
-const openOf = Object.freeze<Readonly<Record<BraceClose, BraceOpen>>>({ "}": "{", "]": "[" });
-const closeOf = Object.freeze<Readonly<Record<BraceOpen, BraceClose>>>({ "{": "}", "[": "]" });
-
-const categorize = (ch: string): Token => {
-  switch (ch) {
-    case '"': return "DQUOTE";
-    case "\\": return "BSLASH";
-    case "{": return "OCB";
-    case "[": return "OSB";
-    case "}": return "CCB";
-    case "]": return "CSB";
-    case "\n": return "NEWLINE";
-    default: return "CHAR";
-  }
-}
-
-type Transition = (ps: ParseState, ch: string, i: number) => ParseState;
-type Table = Readonly<Partial<Record<StateName, Partial<Record<Token, Transition>>>>>;
-
-const push = (ps: ParseState, type: BraceOpen, index: number): ParseState =>
-  ({ ...ps, stack: [...ps.stack, { type, index }] });
-
-const withEdit = (ps: ParseState, edit: Edit): ParseState =>
-  ({ ...ps, edits: [...ps.edits, edit] });
-
-const popOrFix = (ps: ParseState, closer: BraceClose, idx: number): ParseState =>
-  ((): ParseState => {
-    if (ps.stack.length === 0) {
-      // Extra closing brace → delete
-      return withEdit(ps, { op: "delete", index: idx });
-    }
-    const top = ps.stack[ps.stack.length - 1];
-    if (top !== undefined && top.type !== openOf[closer]) {
-      // Type mismatch → replace with expected value + pop
-      const expected = closeOf[top.type];
-      return withEdit({ ...ps, stack: ps.stack.slice(0, -1) }, { op: "replace", index: idx, text: expected });
-    }
-    // Normal matching → pop
-    return { ...ps, stack: ps.stack.slice(0, -1) };
-  })();
-
-const table: Table = {
-  OUT: {
-    DQUOTE: (ps) => ({ ...ps, s: "IN" }),
-    OCB:    (ps, _ch, i) => push(ps, "{", i),
-    OSB:    (ps, _ch, i) => push(ps, "[", i),
-    CCB:    (ps, _ch, i) => popOrFix(ps, "}", i),
-    CSB:    (ps, _ch, i) => popOrFix(ps, "]", i),
-  },
-  IN: {
-    BSLASH: (ps) => ({ ...ps, s: "ESC" }),
-    DQUOTE: (ps) => ({ ...ps, s: "OUT" }),
-  },
-  ESC: {
-    DQUOTE: (ps) => ({ ...ps, s: "IN" }),
-    BSLASH: (ps) => ({ ...ps, s: "IN" }),
-    OCB:    (ps) => ({ ...ps, s: "IN" }),
-    OSB:    (ps) => ({ ...ps, s: "IN" }),
-    CCB:    (ps) => ({ ...ps, s: "IN" }),
-    CSB:    (ps) => ({ ...ps, s: "IN" }),
-    CHAR:   (ps) => ({ ...ps, s: "IN" }),
-    NEWLINE:(ps) => ({ ...ps, s: "IN" }),
-  },
-};
-
-type StateName = "OUT" | "IN" | "ESC";
-type BraceOpen = "{" | "[";
-type BraceClose = "}" | "]";
-type Token = "DQUOTE" | "BSLASH" | "OCB" | "OSB" | "CCB" | "CSB" | "NEWLINE" | "CHAR";
-
-type StackEntry = { type: BraceOpen; index: number };
-type Edit =
-  | { op: "delete"; index: number }
-  | { op: "replace"; index: number; text: string }
-  | { op: "insert"; index: number; text: string };
-
-type ParseState = {
-  s: StateName;
-  stack: ReadonlyArray<StackEntry>;
-  line: number;
-  col: number;
-  edits: ReadonlyArray<Edit>;
-};