tina4-nodejs 3.13.133 → 3.13.134

package/packages/core/src/docsParser.ts

@@ -0,0 +1,270 @@
+// ── TS regex parser ──────────────────────────────────────────────────
+import { stripStrings } from "./docsScanner.js";
+import { matchMethodSignature, matchTopLevelFunction } from "./docsSignatures.js";
+
+export interface ParsedClass {
+  name: string;
+  line: number;
+  doc: string;
+  exported: boolean;
+  methods: ParsedMethod[];
+}
+
+export interface ParsedMethod {
+  name: string;
+  line: number;
+  doc: string;
+  signature: string;
+  visibility: "public" | "protected" | "private";
+  static: boolean;
+}
+
+export interface ParsedFile {
+  classes: ParsedClass[];
+  functions: ParsedMethod[];
+}
+
+const CLASS_RE = /(?:^|\n)([ \t]*)((?:export\s+(?:default\s+)?(?:abstract\s+)?)?class\s+([A-Za-z_$][\w$]*))[\s\S]*?(?=\n[ \t]*(?:export\s+(?:default\s+)?(?:abstract\s+)?class|export\s+function|function|$))/g;
+
+interface ClassContext {
+  name: string;
+  bodyStartDepth: number;
+  entry: ParsedClass;
+  isExport: boolean;
+}
+
+function lineNumberAt(source: string, offset: number): number {
+  let line = 1;
+  for (let i = 0; i < offset && i < source.length; i++) {
+    if (source.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+function readDocComment(stripped: string, source: string, start: number): { doc: string; next: number } | null {
+  if (!(stripped[start] === "/" && stripped[start + 1] === "*" && stripped[start + 2] === "*")) return null;
+  const end = stripped.indexOf("*/", start + 3);
+  return end === -1
+    ? { doc: "", next: -1 }
+    : { doc: source.slice(start, end + 2), next: end + 2 };
+}
+
+function startClass(
+  stripped: string,
+  source: string,
+  lines: string[],
+  index: number,
+  braceDepth: number,
+  pendingDoc: string,
+): { context: ClassContext; next: number } | null {
+  if (!isWordBoundary(stripped, index) || !matchKeyword(stripped, index, "class")) return null;
+  const after = index + "class".length;
+  const nameMatch = /^\s+([A-Za-z_$][\w$]*)/.exec(stripped.slice(after));
+  if (!nameMatch) return null;
+  const name = nameMatch[1];
+  let open = after + nameMatch[0].length;
+  while (open < stripped.length && stripped[open] !== "{") open++;
+  if (open >= stripped.length) return null;
+  const entry: ParsedClass = {
+    name,
+    line: lineNumberAt(source, index),
+    doc: pendingDoc,
+    exported: isExportedAt(stripped, lines, lineNumberAt(source, index), name),
+    methods: [],
+  };
+  return {
+    context: { name, bodyStartDepth: braceDepth, entry, isExport: entry.exported },
+    next: open + 1,
+  };
+}
+
+function closeClasses(
+  braceDepth: number,
+  stack: ClassContext[],
+  classes: ParsedClass[],
+): void {
+  while (stack.length > 0 && braceDepth <= stack[stack.length - 1].bodyStartDepth) {
+    classes.push(stack.pop()!.entry);
+  }
+}
+
+function recordClassMethod(
+  stripped: string,
+  source: string,
+  index: number,
+  stack: ClassContext[],
+  pendingDoc: string,
+): number | null {
+  const match = matchMethodSignature(stripped, source, index);
+  if (!match) return null;
+  const cls = stack[stack.length - 1];
+  cls.entry.methods.push({
+    name: match.name,
+    line: lineNumberAt(source, match.nameStart ?? index),
+    doc: pendingDoc,
+    signature: match.signature,
+    visibility: match.visibility,
+    static: match.static,
+  });
+  return match.endIndex;
+}
+
+function recordTopLevelFunction(
+  stripped: string,
+  source: string,
+  index: number,
+  functions: ParsedMethod[],
+  pendingDoc: string,
+): number | null {
+  const match = matchTopLevelFunction(stripped, source, index);
+  if (!match) return null;
+  functions.push({
+    name: match.name,
+    line: lineNumberAt(source, match.nameStart ?? index),
+    doc: pendingDoc,
+    signature: match.signature,
+    visibility: "public",
+    static: false,
+  });
+  return match.endIndex;
+}
+
+/**
+ * Parse a TS source string. Lightweight — finds top-level classes and their
+ * public methods, plus top-level exported functions. Captures preceding JSDoc.
+ *
+ * Strategy: scan token-by-token. We don't need a full AST — we only care
+ * about identifying class declarations, brace depth (to find class members),
+ * method/function declarations, and JSDoc comments immediately above.
+ */
+export function parseTypeScript(source: string, _debugTag = ""): ParsedFile {
+  const classes: ParsedClass[] = [];
+  const functions: ParsedMethod[] = [];
+
+  // Strip line comments and string contents (preserve length for line numbers).
+  const stripped = stripStrings(source);
+  const lines = source.split(/\r?\n/);
+
+  let i = 0;
+  let pendingDoc = "";
+  const len = stripped.length;
+  let braceDepth = 0;
+  const classStack: ClassContext[] = [];
+
+  while (i < len) {
+    const ch = stripped[i];
+
+    const doc = readDocComment(stripped, source, i);
+    if (doc) {
+      if (doc.next === -1) break;
+      pendingDoc = doc.doc;
+      i = doc.next;
+      continue;
+    }
+
+    // Skip line comments (already stripped → '/' followed by '/' won't appear in stripped, but be safe)
+    if (ch === "/" && stripped[i + 1] === "/") {
+      while (i < len && stripped[i] !== "\n") i++;
+      continue;
+    }
+
+    // Brace tracking (only outside strings; strings are zeroed in stripped)
+    if (ch === "{") {
+      braceDepth++;
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      braceDepth--;
+      closeClasses(braceDepth, classStack, classes);
+      i++;
+      continue;
+    }
+
+    const classStart = startClass(stripped, source, lines, i, braceDepth, pendingDoc);
+    if (classStart) {
+      classStack.push(classStart.context);
+      pendingDoc = "";
+      braceDepth++;
+      i = classStart.next;
+      continue;
+    }
+
+    // Method or top-level function detection — we only care about either:
+    //   * methods inside a class body (classStack non-empty AND directly inside class body)
+    //   * top-level "export function" or "function" declarations
+    if (classStack.length > 0
+        && braceDepth === classStack[classStack.length - 1].bodyStartDepth + 1) {
+      const next = recordClassMethod(stripped, source, i, classStack, pendingDoc);
+      if (next !== null) {
+        pendingDoc = "";
+        i = next;
+        continue;
+      }
+    } else if (braceDepth === 0) {
+      const next = recordTopLevelFunction(stripped, source, i, functions, pendingDoc);
+      if (next !== null) {
+        pendingDoc = "";
+        i = next;
+        continue;
+      }
+    }
+
+    // Whitespace doesn't reset pendingDoc — but most other tokens do.
+    if (!/\s/.test(ch)) {
+      // Non-whitespace, non-doc-comment — only reset doc if it was a long way back.
+      // Be conservative: only reset on punctuation that clearly terminates.
+      if (ch === ";") {
+        pendingDoc = "";
+      }
+    }
+
+    i++;
+  }
+
+  // Any unclosed class (shouldn't happen in valid TS) → flush.
+  while (classStack.length > 0) classes.push(classStack.pop()!.entry);
+
+  return { classes, functions };
+}
+
+function isWordBoundary(text: string, i: number): boolean {
+  if (i === 0) return true;
+  const prev = text.charCodeAt(i - 1);
+  // Word chars: A-Z a-z 0-9 _ $
+  if ((prev >= 65 && prev <= 90) || (prev >= 97 && prev <= 122) || (prev >= 48 && prev <= 57) || prev === 95 || prev === 36) {
+    return false;
+  }
+  return true;
+}
+
+function matchKeyword(text: string, i: number, kw: string): boolean {
+  if (text.substr(i, kw.length) !== kw) return false;
+  const after = i + kw.length;
+  if (after >= text.length) return true;
+  const nextCode = text.charCodeAt(after);
+  if ((nextCode >= 65 && nextCode <= 90) || (nextCode >= 97 && nextCode <= 122) || (nextCode >= 48 && nextCode <= 57) || nextCode === 95 || nextCode === 36) {
+    return false;
+  }
+  return true;
+}
+
+function isExportedAt(_stripped: string, lines: string[], lineNo: number, name: string): boolean {
+  // Walk back up to 8 lines and look for "export class <name>" / "export default class <name>"
+  const start = Math.max(0, lineNo - 1);
+  const exportClass = "export class " + name;
+  const exportDefaultClass = "export default class " + name;
+  const exportAbstractClass = "export abstract class " + name;
+  const justClass = "class " + name;
+  for (let l = start; l >= Math.max(0, start - 8); l--) {
+    const ln = lines[l] || "";
+    if (ln.includes(exportClass) || ln.includes(exportDefaultClass) || ln.includes(exportAbstractClass)) {
+      return true;
+    }
+    if (ln.includes(justClass)) {
+      // declared but not exported
+      return /\bexport\b/.test(ln);
+    }
+  }
+  return false;
+}

package/packages/core/src/docsScanner.ts

@@ -0,0 +1,121 @@
+/**
+ * Replace string literals and template literal contents with spaces of equal
+ * length so brace/paren scanning isn't fooled by characters inside strings.
+ * Also strips line + block comments. Newlines are preserved so line numbers
+ * line up with the original source.
+ */
+const BACKTICK = String.fromCharCode(96);
+
+function blankSegment(source: string, start: number, end: number): string {
+  return source.slice(start, end).replace(/[^\n]/g, " ");
+}
+
+function stripBlockComment(source: string, start: number): { text: string; next: number } {
+  const end = source.indexOf("*/", start + 2);
+  return end === -1
+    ? { text: blankSegment(source, start, source.length), next: source.length }
+    : { text: blankSegment(source, start, end + 2), next: end + 2 };
+}
+
+function stripLineComment(source: string, start: number): { text: string; next: number } {
+  const end = source.indexOf("\n", start);
+  const next = end === -1 ? source.length : end;
+  return { text: " ".repeat(next - start), next };
+}
+
+function stripQuoted(source: string, start: number): { text: string; next: number } {
+  const out = [source[start]];
+  let i = start + 1;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\\" && i + 1 < source.length) {
+      out.push("  ");
+      i += 2;
+      continue;
+    }
+    if (c === source[start]) {
+      out.push(c);
+      i++;
+      break;
+    }
+    out.push(c === "\n" ? "\n" : " ");
+    i++;
+  }
+  return { text: out.join(""), next: i };
+}
+
+function stripTemplateInterpolation(source: string, start: number): { text: string; next: number } {
+  const out = ["  "];
+  let i = start + 2;
+  let depth = 1;
+  while (i < source.length && depth > 0) {
+    const c = source[i];
+    if (c === "{") depth++;
+    else if (c === "}") depth--;
+    out.push(c === "\n" ? "\n" : " ");
+    i++;
+  }
+  return { text: out.join(""), next: i };
+}
+
+function stripTemplate(source: string, start: number): { text: string; next: number } {
+  const out = [BACKTICK];
+  let i = start + 1;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\\" && i + 1 < source.length) {
+      out.push("  ");
+      i += 2;
+      continue;
+    }
+    if (c === BACKTICK) {
+      out.push(BACKTICK);
+      i++;
+      break;
+    }
+    if (c === "$" && source[i + 1] === "{") {
+      const interpolation = stripTemplateInterpolation(source, i);
+      out.push(interpolation.text);
+      i = interpolation.next;
+      continue;
+    }
+    out.push(c === "\n" ? "\n" : " ");
+    i++;
+  }
+  return { text: out.join(""), next: i };
+}
+
+export function stripStrings(source: string): string {
+  const out: string[] = [];
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "/" && source[i + 1] === "*") {
+      const part = stripBlockComment(source, i);
+      out.push(part.text);
+      i = part.next;
+      continue;
+    }
+    if (c === "/" && source[i + 1] === "/") {
+      const part = stripLineComment(source, i);
+      out.push(part.text);
+      i = part.next;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      const part = stripQuoted(source, i);
+      out.push(part.text);
+      i = part.next;
+      continue;
+    }
+    if (c === BACKTICK) {
+      const part = stripTemplate(source, i);
+      out.push(part.text);
+      i = part.next;
+      continue;
+    }
+    out.push(c);
+    i++;
+  }
+  return out.join("");
+}

package/packages/core/src/docsSignatures.ts

@@ -0,0 +1,165 @@
+interface MethodMatch {
+  name: string;
+  signature: string;
+  endIndex: number;
+  nameStart: number;
+  visibility: "public" | "protected" | "private";
+  static: boolean;
+}
+
+const METHOD_HEAD_RE =
+  /^([ \t]*)((?:public|protected|private|readonly|static|async|abstract|override|\s)*)([A-Za-z_$][\w$]*)\s*[<(]/;
+
+export function matchMethodSignature(stripped: string, source: string, i: number): MethodMatch | null {
+  // Method must be at start-of-line-ish position.
+  if (i > 0) {
+    const prev = stripped.charCodeAt(i - 1);
+    if (prev !== 10 && prev !== 32 && prev !== 9 && prev !== 123) return null;
+  }
+  // Take the rest of the current line + a little ahead.
+  let lineEnd = stripped.indexOf("\n", i);
+  if (lineEnd === -1) lineEnd = stripped.length;
+  // Read up to 4 lines for multi-line signatures.
+  let chunkEnd = lineEnd;
+  for (let extra = 0; extra < 4 && chunkEnd < stripped.length; extra++) {
+    const next = stripped.indexOf("\n", chunkEnd + 1);
+    if (next === -1) break;
+    chunkEnd = next;
+  }
+  const chunk = stripped.slice(i, chunkEnd + 1);
+  const match = METHOD_HEAD_RE.exec(chunk);
+  if (!match) return null;
+  const modifiers = match[2] || "";
+  const name = match[3];
+  // Skip reserved words / control-flow that masquerade as method names.
+  const reserved = new Set([
+    "if", "for", "while", "switch", "return", "do", "try", "catch", "throw",
+    "const", "let", "var", "import", "export", "function", "class", "interface",
+    "type", "new", "yield", "await", "case", "break", "continue", "else",
+  ]);
+  if (reserved.has(name)) return null;
+
+  // Determine visibility from modifiers
+  let visibility: "public" | "protected" | "private" = "public";
+  if (/\bprivate\b/.test(modifiers)) visibility = "private";
+  else if (/\bprotected\b/.test(modifiers)) visibility = "protected";
+  const isStatic = /\bstatic\b/.test(modifiers);
+
+  // Capture signature — read from start of "name" up through matching ')' and optional return type.
+  const nameStart = i + match[1].length + match[2].length;
+  const result = captureSignature(stripped, source, nameStart, name);
+  if (!result) return null;
+
+  return {
+    name,
+    signature: result.signature,
+    endIndex: result.endIndex,
+    nameStart,
+    visibility,
+    static: isStatic,
+  };
+}
+
+const FN_HEAD_RE =
+  /^((?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+)([A-Za-z_$][\w$]*)\s*[<(]/;
+
+export function matchTopLevelFunction(stripped: string, source: string, i: number): MethodMatch | null {
+  if (i > 0) {
+    const prev = stripped.charCodeAt(i - 1);
+    if (prev !== 10 && prev !== 32 && prev !== 9) return null;
+  }
+  let lineEnd = stripped.indexOf("\n", i);
+  if (lineEnd === -1) lineEnd = stripped.length;
+  let chunkEnd = lineEnd;
+  for (let extra = 0; extra < 4 && chunkEnd < stripped.length; extra++) {
+    const next = stripped.indexOf("\n", chunkEnd + 1);
+    if (next === -1) break;
+    chunkEnd = next;
+  }
+  const chunk = stripped.slice(i, chunkEnd + 1);
+  const match = FN_HEAD_RE.exec(chunk);
+  if (!match) return null;
+  const name = match[2];
+  const nameStart = i + match[1].length;
+  const result = captureSignature(stripped, source, nameStart, name);
+  if (!result) return null;
+  return {
+    name,
+    signature: result.signature,
+    endIndex: result.endIndex,
+    nameStart,
+    visibility: "public",
+    static: false,
+  };
+}
+
+interface CapturedSig {
+  signature: string;
+  endIndex: number;
+}
+
+function skipWhitespace(text: string, start: number, spacesOnly = false): number {
+  let i = start;
+  while (i < text.length && (spacesOnly ? /[ \t]/.test(text[i]) : /\s/.test(text[i]))) i++;
+  return i;
+}
+
+function scanBalanced(text: string, start: number, open: string, close: string): number {
+  let depth = 0;
+  let i = start;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === open) depth++;
+    else if (c === close) {
+      depth--;
+      if (depth === 0) return i + 1;
+    }
+    i++;
+  }
+  return i;
+}
+
+function returnTypeStops(stripped: string, index: number, depth: number): boolean {
+  const c = stripped[index];
+  if (depth === 0 && (c === "{" || c === ";")) return true;
+  if (depth !== 0 || c !== "\n") return false;
+  const next = skipWhitespace(stripped, index + 1, true);
+  return stripped[next] === "{";
+}
+
+function updateReturnDepth(char: string, depth: number): number {
+  if (char === "<" || char === "(" || char === "[") return depth + 1;
+  if (char === ">" || char === ")" || char === "]") return depth - 1;
+  return depth;
+}
+
+function captureReturnType(stripped: string, source: string, start: number): { endIndex: number; returnType: string } {
+  const retStart = skipWhitespace(stripped, start, true);
+  if (stripped[retStart] !== ":") return { endIndex: retStart, returnType: "" };
+
+  let retEnd = retStart + 1;
+  let depth = 0;
+  while (retEnd < stripped.length) {
+    const c = stripped[retEnd];
+    if (returnTypeStops(stripped, retEnd, depth)) break;
+    depth = updateReturnDepth(c, depth);
+    retEnd++;
+  }
+  return { endIndex: retEnd, returnType: source.slice(retStart, retEnd).trim() };
+}
+
+function captureSignature(stripped: string, source: string, nameStart: number, name: string): CapturedSig | null {
+  let j = skipWhitespace(stripped, nameStart + name.length);
+  if (stripped[j] === "<") j = scanBalanced(stripped, j, "<", ">");
+  j = skipWhitespace(stripped, j);
+  if (stripped[j] !== "(") return null;
+
+  const parenStart = j;
+  j = scanBalanced(stripped, j, "(", ")");
+  const parenSegment = source.slice(parenStart, j); // pull from original source for human-readable
+  const result = captureReturnType(stripped, source, j);
+  const cleanedParens = parenSegment.replace(/\s+/g, " ");
+  const sig = name + cleanedParens + (result.returnType ? " " + result.returnType : "");
+  return { signature: sig, endIndex: result.endIndex };
+}
+

package/packages/core/src/index.ts

@@ -109,6 +109,8 @@ export { AI_TOOLS, isInstalled, showMenu, installSelected, installAll, generateC
 export type { AiTool } from "./ai.js";
 export { Sso, SSO, SsoError } from "./sso.js";
 export type { SsoOptions } from "./sso.js";
+export { Push, PushError, generateVapidKeys } from "./push.js";
+export type { PushOptions, PushSubscription, PushResult, PushPayload } from "./push.js";
 export { Ai, AiError, AiConfigError, AiHTTPError, AiTimeoutError, AiParseError } from "./aiClient.js";
 export type { ChatResponse, AiMessage, AiChatOptions, AiEmbedOptions, AiEvent, ContentPart, AiMessageContent, AiToolDeclaration, AiToolChoice } from "./aiClient.js";
 export type { ImapMessage, ImapFullMessage, ImapAttachment } from "./messenger.js";