@allansantos-dev/smart-tool 0.0.0-stage → 0.9.0

package/code_graph.py

@@ -0,0 +1,403 @@
+"""Grafos estáticos do conteúdo indexado: cobertura, imports e chamadas resolvidas."""
+import ast
+import collections
+import copy
+import contextvars
+import hashlib
+import json
+import os
+import posixpath
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+import indexer
+import index_inventory
+import project_identity
+import web_search_adapters
+import web_document_graph
+import document_text
+
+VERSION = 2
+MAX_FILES = 3000
+MAX_TEXT = 24 * 1024 * 1024
+MAX_SYMBOLS = 8000
+MAX_EDGES = 20000
+_CACHE = collections.OrderedDict()
+_LOCK = threading.Lock()
+_ANALYSIS_SLOTS = threading.BoundedSemaphore(2)
+_WARM_SLOT = threading.BoundedSemaphore(1)
+_WARMING = set()
+_WARM_STATE = {}
+WARM_RETRY_S = 600
+
+
+def reconstruct(rows):
+    """Remove sobreposição de chunks e recusa buracos/conflitos; mantém linhas reais."""
+    lines = {}
+    previous = None
+    for start, end, text in rows:
+        parts = text.splitlines(keepends=True)
+        if len(parts) != end-start+1:
+            return None, 'Chunks do not reconstruct the full lines of the file.'
+        for offset, part in enumerate(parts):
+            line = start+offset
+            if line in lines and start == end == line and previous and previous[0] == previous[1] == line and not previous[2].endswith(('\n','\r')):
+                lines[line] += part
+            elif line in lines and lines[line] != part:
+                return None, 'Overlapping chunks contain conflicting versions.'
+            else:
+                lines[line] = part
+        previous = (start,end,text)
+    if not lines:
+        return '', None
+    if min(lines) != 1 or len(lines) != max(lines):
+        return None, 'The snapshot has gaps; relations were not inferred for this file.'
+    return ''.join(lines[i] for i in range(1,max(lines)+1)), None
+
+
+def _snapshot(path):
+    conn = indexer._readonly(path)
+    try:
+        conn.execute('BEGIN')
+        columns = {row[1] for row in conn.execute('PRAGMA table_info(manifest)')}
+        size = 'm.size' if 'size' in columns else 'NULL'
+        mtime = 'm.mtime_ns' if 'mtime_ns' in columns else 'NULL'
+        records = conn.execute(f'SELECT m.path,m.hash,{size},{mtime},count(c.id),max(c.end_line) FROM manifest m LEFT JOIN chunks c ON c.path=m.path GROUP BY m.path ORDER BY m.path LIMIT ?', (MAX_FILES+1,)).fetchall()
+        files, sources, diagnostics, used = [], {}, [], 0
+        for original, digest, byte_size, stamp, chunks, line_count in records[:MAX_FILES]:
+            file_path = original.replace('\\','/')
+            record = {'id':file_path,'path':file_path,'hash':digest,'size':byte_size,'mtime_ns':stamp,
+                      'chunks':chunks,'lines':line_count or 0,'group':posixpath.dirname(file_path) or '(root)',
+                      'location_kind':document_text.location_kind(file_path),'format':posixpath.splitext(file_path)[1].lower().lstrip('.') or 'text'}
+            files.append(record)
+            if not file_path.lower().endswith(('.py','.java','.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts','.json','.html','.htm','.css','.scss','.sass','.less','.md','.markdown')):
+                continue
+            rows = conn.execute('SELECT start_line,end_line,text FROM chunks WHERE path=? ORDER BY start_line,id', (original,)).fetchall()
+            text, error = reconstruct(rows)
+            if error:
+                diagnostics.append({'path':file_path,'reason':error})
+            elif used+len(text) > MAX_TEXT:
+                diagnostics.append({'path':file_path,'reason':'Content limit for this analysis reached.'})
+            else:
+                used += len(text)
+                sources[file_path] = text
+        return files, sources, diagnostics, len(records)>MAX_FILES
+    finally:
+        conn.close()
+
+
+def _python_graph(sources):
+    trees, symbols, dependencies, calls, unresolved, diagnostics = {}, [], [], [], [], []
+    decls, aliases, scopes, classes, owners, shadow_scopes, node_symbols = {}, {}, {}, {}, {}, {}, {}
+    def bind_import(path,scope,name,binding):
+        table=aliases[path].setdefault(scope,{})
+        table[name]=binding if name not in table or table[name]==binding else None
+    def resolve_file(spec):
+        spec=posixpath.normpath(spec)
+        return next((p for p in (spec+'.py',spec+'/__init__.py','src/'+spec+'.py','src/'+spec+'/__init__.py') if p in sources), None)
+    for path, text in sources.items():
+        if not path.endswith('.py'):
+            continue
+        try:
+            tree=ast.parse(text,filename=path)
+        except (SyntaxError,ValueError,RecursionError) as exc:
+            diagnostics.append({'path':path,'reason':'Incomplete or invalid Python syntax in the snapshot.','line':getattr(exc,'lineno',None)})
+            continue
+        trees[path]=tree;aliases[path]={};decls[path]={};classes[path]={}
+        def collect(node,qual=(),owner=None):
+            if isinstance(node,(ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef)):
+                qual=qual+(node.name,)
+                sym={'id':path+'::'+'.'.join(qual)+'@'+str(node.lineno),'path':path,'name':'.'.join(qual),
+                     'start_line':node.lineno,'end_line':node.end_lineno,'kind':'class' if isinstance(node,ast.ClassDef) else 'function', 'language':'python'}
+                decls[path][qual]=sym if qual not in decls[path] else None
+                scopes[id(node)]=qual;node_symbols[id(node)]=sym
+                if isinstance(node,ast.ClassDef):classes[path][qual]=node
+                if len(symbols)<MAX_SYMBOLS:symbols.append(sym)
+                owner=sym
+            owners[id(node)]=qual
+            for child in ast.iter_child_nodes(node):collect(child,qual,owner)
+        collect(tree)
+        for node in ast.walk(tree):
+            if isinstance(node,ast.Import):
+                for item in node.names:
+                    spec=item.name.replace('.','/');target=resolve_file(spec)
+                    bind_import(path,owners[id(node)],item.asname or item.name,(target,None))
+                    dependencies.append({'source':path,'target':target,'specifier':item.name,'line':node.lineno,'kind':'import','resolution':'resolved' if target else 'external'})
+            elif isinstance(node,ast.ImportFrom):
+                prefix=posixpath.dirname(path)
+                if node.level:
+                    for _ in range(node.level-1):prefix=posixpath.dirname(prefix)
+                    spec=posixpath.join(prefix,(node.module or '').replace('.','/'))
+                else:spec=(node.module or '').replace('.','/')
+                base=resolve_file(spec)
+                for item in node.names:
+                    target=resolve_file(spec+'/'+item.name) if item.name!='*' else None
+                    target=target or base
+                    bind_import(path,owners[id(node)],item.asname or item.name,(target,None if target and target!=base else item.name))
+                    dependencies.append({'source':path,'target':target,'specifier':('.'*node.level)+(node.module or '')+'.'+item.name,'line':node.lineno,'kind':'import','resolution':'resolved' if target else 'unresolved' if node.level else 'external'})
+    def chain(expr):
+        if isinstance(expr,ast.Name):return expr.id
+        if isinstance(expr,ast.Attribute):
+            base=chain(expr.value)
+            return base+'.'+expr.attr if base else None
+        return None
+    def resolve(path,qual,name,shadow,instances):
+        if not name:return None
+        parts=name.split('.')
+        if parts[0] in instances:
+            typ=instances[parts[0]]
+            return decls.get(typ['path'],{}).get(tuple(typ['name'].split('.'))+tuple(parts[1:]))
+        if parts[0] in ('self','cls') and len(parts)>1:
+            for i in range(len(qual),0,-1):
+                if qual[:i] in classes[path]:return decls[path].get(qual[:i]+tuple(parts[1:]))
+        if parts[0] in shadow:return None
+        for i in range(len(qual),-1,-1):
+            if i<len(qual) and qual[:i] in classes[path]:
+                continue  # O namespace da classe não é escopo lexical de seus métodos.
+            if parts[0] in shadow_scopes.get((path,qual[:i]),set()):
+                return None
+            if qual[:i]+tuple(parts) in decls[path]:
+                return decls[path][qual[:i]+tuple(parts)]
+            for length in range(len(parts),0,-1):
+                table=aliases[path].get(qual[:i],{})
+                binding=table.get('.'.join(parts[:length]))
+                if '.'.join(parts[:length]) in table:
+                    if binding is None:return None
+                    target_path,imported=binding
+                    rest=(([imported] if imported and imported!='*' else [])+parts[length:])
+                    return decls.get(target_path,{}).get(tuple(rest))
+        return None
+    for path,tree in trees.items():
+        module={'id':path+'::<module>','path':path,'name':'<module>','start_line':1,'end_line':1,'kind':'module','language':'python'}
+        used_module=False
+        def visit_scope(node,qual=()):
+            nonlocal used_module
+            owner=node_symbols.get(id(node),module)
+            shadow=set();instances={}
+            args=getattr(node,'args',None)
+            if args:
+                params=[*args.posonlyargs,*args.args,*args.kwonlyargs]+([args.vararg] if args.vararg else [])+([args.kwarg] if args.kwarg else [])
+                shadow.update(arg.arg for arg in params)
+                for arg in params:
+                    target=resolve(path,qual,chain(arg.annotation),set(),{}) if arg.annotation else None
+                    if target and target['kind']=='class':instances[arg.arg]=target
+            # Levanta ligações locais sem atravessar escopos aninhados.
+            def local_nodes(n):
+                for child in ast.iter_child_nodes(n):
+                    if isinstance(child,(ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef,ast.Lambda)):
+                        continue
+                    yield child
+                    yield from local_nodes(child)
+            local=list(local_nodes(node))
+            assigned={}
+            for n in local:
+                if isinstance(n,(ast.Assign,ast.AnnAssign)):
+                    targets=n.targets if isinstance(n,ast.Assign) else [n.target]
+                    for target in targets:
+                        if isinstance(target,ast.Name):
+                            shadow.add(target.id);assigned.setdefault(target.id,[]).append(n.value)
+            for name,values in assigned.items():
+                if len(values)==1 and isinstance(values[0],ast.Call):
+                    typ=resolve(path,qual,chain(values[0].func),shadow-set([name]),instances)
+                    if typ and typ['kind']=='class':instances[name]=typ
+            shadow_scopes[(path,qual)]=shadow
+            for n in local:
+                if not isinstance(n,ast.Call):continue
+                expr=chain(n.func)
+                target=resolve(path,qual,expr,shadow,instances)
+                if target:
+                    if owner is module:used_module=True
+                    if len(calls)<MAX_EDGES:calls.append({'source':owner['id'],'target':target['id'],'line':n.lineno,'kind':'construct' if target['kind']=='class' else 'call','resolution':'static'})
+                elif len(unresolved)<1000:
+                    unresolved.append({'path':path,'line':n.lineno,'expression':expr or '<dynamic expression>','reason':'External, dynamic or unresolved target in this snapshot.'})
+            for child in ast.iter_child_nodes(node):
+                if isinstance(child,(ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef)):
+                    visit_scope(child,scopes[id(child)])
+                else:
+                    # Definições em blocos if/try também podem declarar escopos.
+                    def nested(n):
+                        for c in ast.iter_child_nodes(n):
+                            if isinstance(c,(ast.FunctionDef,ast.AsyncFunctionDef,ast.ClassDef)):visit_scope(c,scopes[id(c)])
+                            else:nested(c)
+                    nested(child)
+        visit_scope(tree)
+        if used_module:symbols.append(module)
+    return {'symbols':symbols,'dependencies':dependencies[:MAX_EDGES],'calls':calls,'unresolved':unresolved,
+            'diagnostics':diagnostics,'parsed':list(trees),'truncated':len(symbols)>=MAX_SYMBOLS or len(dependencies)>MAX_EDGES}
+
+
+def _javascript_graph(sources, all_paths=None):
+    extensions=('.js','.jsx','.ts','.tsx','.mjs','.cjs','.mts','.cts')
+    relevant={path:text for path,text in sources.items() if path.endswith(extensions+('.json','.html','.htm'))}
+    if not any(path.endswith(extensions) for path in relevant):
+        return {}
+    try:
+        process=subprocess.run([web_search_adapters.NODE_EXECUTABLE,'--max-old-space-size=512',str(Path(__file__).with_name('code_graph_js.cjs'))],
+            input=json.dumps({'files':[{'path':path,'text':text} for path,text in relevant.items()],'paths':list(all_paths or sources)},ensure_ascii=False),
+            capture_output=True,text=True,encoding='utf-8',timeout=40,
+            creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+        if process.returncode:
+            raise RuntimeError('The TypeScript analyzer did not finish. Check the local code-analysis runtime.')
+        return json.loads(process.stdout)
+    except (OSError,subprocess.TimeoutExpired,ValueError,RuntimeError) as exc:
+        return {'diagnostics':[{'path':'JavaScript/TypeScript','reason':str(exc)[:250]}],'parsed':[],'retryable':True}
+
+
+def _java_graph(sources):
+    files=[{'path':path,'text':text} for path,text in sources.items() if path.lower().endswith('.java')]
+    if not files:return {}
+    try:
+        result=subprocess.run([web_search_adapters.NODE_EXECUTABLE,'--max-old-space-size=512',str(Path(__file__).with_name('code_graph_java.mjs'))],
+            input=json.dumps({'files':files},ensure_ascii=False),capture_output=True,text=True,encoding='utf-8',timeout=40,
+            creationflags=getattr(subprocess,'CREATE_NO_WINDOW',0))
+        if result.returncode:raise RuntimeError('The Java analyzer did not finish. Check the local runtime.')
+        return json.loads(result.stdout)
+    except (OSError,ValueError,RuntimeError,subprocess.TimeoutExpired) as exc:
+        return {'diagnostics':[{'path':'Java','reason':str(exc)[:250]}],'parsed':[],'retryable':True}
+
+
+def _analyze(path):
+    files,sources,diagnostics,truncated=_snapshot(path)
+    merged={'symbols':[],'dependencies':[],'calls':[],'unresolved':[],'diagnostics':diagnostics,'parsed':[]}
+    retryable=False
+    for output in (_python_graph(sources),_javascript_graph(sources,[f['path'] for f in files]),_java_graph(sources),web_document_graph.analyze(sources,[f['path'] for f in files])):
+        for key in merged:merged[key].extend(output.get(key,[]))
+        truncated |= output.get('truncated',False)
+        retryable |= output.get('retryable',False)
+    by_id={sym['id']:sym for sym in merged['symbols'][:MAX_SYMBOLS]}
+    # Relações repetidas preservam contagem e locais de chamada sem poluir o desenho.
+    def collapse(rows,fields):
+        result={}
+        for row in rows:
+            key=tuple(row.get(field) for field in fields)
+            if key not in result:result[key]={**row,'count':0,'lines':[]}
+            result[key]['count']+=1
+            if len(result[key]['lines'])<20:result[key]['lines'].append(row.get('line'))
+        return list(result.values())
+    deps=collapse(merged['dependencies'],('source','target','specifier','kind'))
+    calls=collapse([r for r in merged['calls'] if r['source'] in by_id and r['target'] in by_id],('source','target','kind'))
+    supported=set(merged['parsed'])
+    for file in files:file['analysis']='parsed' if file['path'] in supported else 'not_analyzed'
+    return {'files':files,'symbols':merged['symbols'][:MAX_SYMBOLS],
+            'dependencies':deps[:MAX_EDGES],'calls':calls[:MAX_EDGES],
+            'unresolved':merged['unresolved'][:1000],'diagnostics':merged['diagnostics'],
+            'truncated':truncated or len(deps)>MAX_EDGES or len(calls)>MAX_EDGES,'retryable':retryable,
+            'counts':{'files':len(files),'parsed_files':len(supported),'symbols':len(merged['symbols']),
+                      'resolved_imports':sum(bool(r['target']) for r in deps),
+                      'external_imports':sum(r['resolution']=='external' for r in deps),
+                      'unresolved_calls':len(merged['unresolved']),'calls':len(calls)}}
+
+
+def _focus(data,file_path):
+    if not isinstance(file_path,str):
+        raise ValueError('file_path must be a string.')
+    target=file_path.replace('\\','/').removeprefix('./')
+    files=[f for f in data['files'] if f['path']==target]
+    if not files:
+        raise ValueError(f'File is outside the indexed view: {file_path}')
+    by_id={s['id']:s for s in data['symbols']}
+    own={s['id'] for s in data['symbols'] if s.get('path')==target}
+    calls=[c for c in data['calls'] if c['source'] in own or c['target'] in own]
+    linked=own|{c['source'] for c in calls}|{c['target'] for c in calls}
+    deps=[d for d in data['dependencies'] if target in (d['source'],d['target'])]
+    paths={f['path'] for f in data['files']}
+    data.update(files=files,symbols=[by_id[i] for i in linked if i in by_id],dependencies=deps,calls=calls,
+                unresolved=[u for u in data['unresolved'] if u.get('path')==target],
+                diagnostics=[d for d in data['diagnostics'] if d.get('path')==target or d.get('path') not in paths],
+                focus={'file_path':target,'symbols':len(own),'imported_by':sum(d['target']==target for d in deps),
+                       'imports':sum(d['source']==target for d in deps),
+                       'incoming_calls':sum(c['target'] in own and c['source'] not in own for c in calls),
+                       'outgoing_calls':sum(c['source'] in own and c['target'] not in own for c in calls)})
+    return data
+
+
+def _by_file(data):
+    by_file={}
+    for symbol in data['symbols']:
+        by_file.setdefault(symbol['path'],[]).append(symbol)
+    parsed={f['path'] for f in data['files'] if f.get('analysis')=='parsed'}
+    note='Graph truncated by analysis limits; some files have no functions.' if data.get('truncated') else None
+    return {'symbols':by_file,'parsed':parsed,'note':note}
+
+
+def cached_symbols(root):
+    path=indexer.existing_db_path(root)
+    if not path:
+        return None,None
+    stat=os.stat(path);key=(path,stat.st_mtime_ns,stat.st_size,VERSION)
+    with _LOCK:
+        data=_CACHE.get(key)
+        if data is not None:
+            _CACHE.move_to_end(key)
+        state=_WARM_STATE.get(root)
+        if data is None and state and state['key']==key and (state['result'] or time.time()-state['at']<WARM_RETRY_S):
+            return state['result'],state['note']
+        start=data is None and root not in _WARMING
+        if start:_WARMING.add(root)
+    if data is not None:
+        return _by_file(data),None
+    if start:
+        context=contextvars.copy_context()
+        threading.Thread(target=context.run,args=(_warm,root,key),daemon=True).start()
+    return None,None
+
+
+def _warm(root,key):
+    result,note=None,None
+    try:
+        data=build(root,background=True)
+        if data.get('retryable'):
+            result=_by_file(data)
+            reasons='; '.join(d.get('reason','') for d in data.get('diagnostics',[])[:2])
+            note=f'Partial analysis: {reasons}'[:300]
+    except Exception as exc:
+        note=f'The last analysis failed: {type(exc).__name__}: {exc}'[:300]
+    finally:
+        with _LOCK:
+            if note:_WARM_STATE[root]={'key':key,'at':time.time(),'result':result,'note':note}
+            else:_WARM_STATE.pop(root,None)
+            _WARMING.discard(root)
+
+
+def build(root,view_id=None,storage_id=None,file_path=None,background=False):
+    inventory=index_inventory.inspect(root,view_id,storage_id=storage_id)
+    if not inventory['selected']:
+        return {**inventory,'symbols':[],'dependencies':[],'calls':[],'diagnostics':[],'counts':{}}
+    path=inventory['selected']['path'];stat=os.stat(path)
+    key=(path,stat.st_mtime_ns,stat.st_size,VERSION)
+    with _LOCK:
+        cached=_CACHE.get(key)
+        if cached:_CACHE.move_to_end(key)
+    was_cached=cached is not None
+    if cached is None:
+        slots=_WARM_SLOT if background else _ANALYSIS_SLOTS
+        if not slots.acquire(timeout=None if background else 3):
+            raise RuntimeError('Two map analyses are in progress. Wait for them to finish and reload.')
+        try:
+            cached=_analyze(path)
+        finally:
+            slots.release()
+        after=os.stat(path)
+        if not cached['retryable'] and (after.st_mtime_ns,after.st_size)==(stat.st_mtime_ns,stat.st_size):
+            with _LOCK:
+                _CACHE[key]=cached
+                while len(_CACHE)>3:_CACHE.popitem(last=False)
+    data=copy.deepcopy(cached)
+    # Só compara metadados do diretório de trabalho quando a visão é a atual.
+    for file in data['files']:
+        file['status']='stored'
+        if inventory['selected']['current'] and file.get('mtime_ns'):
+            candidate=os.path.join(root,file['path'])
+            if project_identity.within_root(root,candidate):
+                try:
+                    current=os.stat(candidate)
+                    file['status']='indexed' if (current.st_mtime_ns,current.st_size)==(file['mtime_ns'],file['size']) else 'pending'
+                except OSError:file['status']='missing'
+        file.pop('mtime_ns',None)
+    data.update(views=inventory['views'],selected=inventory['selected'],current_view=inventory['current_view'],
+                message=inventory['message'],read_only=True,source='indexed_snapshot',generated_at=time.time(),
+                limits={'files':MAX_FILES,'symbols':MAX_SYMBOLS,'edges':MAX_EDGES,'display_nodes_default':120},
+                languages=['Java','Angular','Python','JavaScript','TypeScript','JSX','TSX','HTML','CSS','Markdown'],cache_hit=was_cached)
+    return _focus(data,file_path) if file_path else data

package/code_graph_java.mjs

@@ -0,0 +1,49 @@
+// Análise estática conservadora de Java a partir de snapshots; nenhum código é executado.
+import fs from 'node:fs';
+import {parse} from './web_adapters/node/node_modules/java-parser/src/index.js';
+const input=JSON.parse(fs.readFileSync(0,'utf8'));
+const symbols=[],dependencies=[],calls=[],unresolved=[],diagnostics=[],units=[],classes=new Map(),methodNodes=new Map();
+const MAX_SYMBOLS=8000,MAX_EDGES=20000;
+function children(n){return n?.children?Object.values(n.children).flat().filter(x=>x.children):[]}
+function all(n,name,stop=false){const result=[];function visit(node){if(node?.name===name){result.push(node);if(stop)return}for(const child of children(node))visit(child)}visit(n);return result}
+function first(n,name){return all(n,name,true)[0]}
+function identifiers(n){const out=[];function visit(node){if(node?.children)for(const [key,items] of Object.entries(node.children))for(const child of items){if(child.children)visit(child);else if(key==='Identifier')out.push(child)}}visit(n);return out.sort((a,b)=>a.startOffset-b.startOffset)}
+function text(u,n){return n?.location?u.text.slice(n.location.startOffset,n.location.endOffset+1):''}
+function addSymbol(u,n,name,kind){if(symbols.length>=MAX_SYMBOLS)return null;const s={id:u.path+'::'+name+'@'+n.location.startLine+':'+n.location.startOffset,path:u.path,name,kind,language:'java',start_line:n.location.startLine,end_line:n.location.endLine};symbols.push(s);return s}
+const classKinds=new Set(['normalClassDeclaration','normalInterfaceDeclaration','enumDeclaration','recordDeclaration']);
+for(const file of input.files){try{const tree=parse(file.text),pkg=first(tree,'packageDeclaration'),unit={...file,tree,package:pkg?identifiers(pkg).map(t=>t.image).join('.'): '',imports:[],classes:[]};
+ for(const n of all(tree,'importDeclaration')){const raw=text(unit,n).replace(/^import\s+/,'').replace(/;\s*$/,'').trim(),stat=raw.startsWith('static '),spec=(stat?raw.slice(7):raw).replace(/\s+/g,'');unit.imports.push({spec,static:stat,line:n.location.startLine})}
+ function scan(n,parent=null){let current=parent;if(classKinds.has(n.name)){const id=first(n,'typeIdentifier')||first(n,'typeName'),short=identifiers(id||n)[0]?.image;if(!short)return;const local=(parent?parent.local+'.':'')+short,fqn=(unit.package?unit.package+'.':'')+local;const symbol=addSymbol(unit,n,local,n.name==='normalInterfaceDeclaration'?'interface':'class');if(!symbol)return;current={unit,fqn,local,short,symbol,node:n,body:n.children.classBody?.[0]||n.children.interfaceBody?.[0]||n.children.recordBody?.[0]||n.children.enumBody?.[0],methods:[],fields:new Map(),extends:text(unit,n.children.classExtends?.[0]).replace(/^extends\s+/, '').trim()};classes.set(fqn,classes.has(fqn)?null:current);unit.classes.push(current)}
+ if(current&&n.name==='classBody'&&n!==current.body)return;
+ if(current&&['methodDeclaration','interfaceMethodDeclaration','constructorDeclaration','compactConstructorDeclaration'].includes(n.name)){const declarator=first(n,'methodDeclarator')||first(n,'constructorDeclarator'),ctor=n.name.includes('Constructor')||n.name==='constructorDeclaration',name=ctor?current.short:(declarator?.children.Identifier?.[0]?.image);if(name){const params=all(declarator||n,'formalParameter'),types=params.map(p=>text(unit,first(p,'unannType'))||'?');const signature=name+'('+types.join(',')+')';const sym=addSymbol(unit,n,current.local+'.'+signature,ctor?'constructor':'method');if(sym){sym.signature=signature;const method={symbol:sym,name,arity:params.length,types,node:n,cls:current,params,concrete:!!first(n,'block')||ctor};current.methods.push(method);methodNodes.set(n,method)}}}
+ for(const child of children(n))scan(child,current)}scan(tree);units.push(unit)
+ }catch{diagnostics.push({path:file.path,reason:'Invalid or fragmented Java, or syntax not supported by the parser.'})}}
+function resolveType(unit,raw,context){let name=raw.replace(/@[\w.]+(?:\([^)]*\))?/g,'').replace(/<.*>/g,'').replace(/\[\]|\.\.\./g,'').trim();if(!name||['void','boolean','byte','short','int','long','float','double','char','var'].includes(name))return null;if(classes.has(name))return classes.get(name);const candidates=new Set();const local=[context?context.fqn+'.'+name:'',unit.package?unit.package+'.'+name:name];for(const fq of local)if(classes.has(fq))candidates.add(fq);for(const item of unit.imports.filter(i=>!i.static)){if(item.spec.endsWith('.'+name)&&classes.has(item.spec))candidates.add(item.spec);if(item.spec.endsWith('.*')){const fq=item.spec.slice(0,-1)+name;if(classes.has(fq))candidates.add(fq)}}return candidates.size===1?classes.get([...candidates][0]):null}
+function lookupMethod(cls,name,arity,visited=new Set()){if(!cls||visited.has(cls.fqn))return null;visited.add(cls.fqn);const methods=cls.methods.filter(m=>m.name===name&&m.arity===arity&&m.concrete);if(methods.length===1)return methods[0].symbol;if(methods.length>1)return null;return cls.extends?lookupMethod(resolveType(cls.unit,cls.extends,cls),name,arity,visited):null}
+function putBinding(map,name,type){if(name)map.set(name,map.has(name)&&map.get(name)!==type?null:type)}
+function scoped(node,name){const out=[];function scan(n){if(n!==node&&(classKinds.has(n.name)||n.name==='lambdaExpression'||n.name==='classBody'))return;if(n.name===name)out.push(n);for(const c of children(n))scan(c)}scan(node);return out}
+function collectVariables(unit,node,map){for(const parentName of ['fieldDeclaration','localVariableDeclaration','variableParaRegularParameter','variableArityParameter'])for(const declaration of scoped(node,parentName)){const type=text(unit,first(declaration,'unannType'));for(const id of all(declaration,'variableDeclaratorId'))putBinding(map,identifiers(id)[0]?.image,type)}}
+for(const unit of units){for(const cl of unit.classes){const fieldNodes=scoped(cl.body,'fieldDeclaration');for(const node of fieldNodes){const type=text(unit,first(node,'unannType'));for(const id of all(node,'variableDeclaratorId'))putBinding(cl.fields,identifiers(id)[0]?.image,type)}}}
+for(const unit of units){
+ for(const item of unit.imports){const spec=item.spec;let target=classes.get(item.static?spec.split('.').slice(0,-1).join('.'):spec);dependencies.push({source:unit.path,target:target?.unit.path||null,specifier:spec,line:item.line,kind:item.static?'java_static_import':'import',resolution:target?'resolved':'external'})}
+ function walk(n,cls=null,method=null,vars=new Map(),owner=null){if(classKinds.has(n.name))cls=unit.classes.find(c=>c.node===n)||cls;if(cls&&n.name==='classBody'&&n!==cls.body)return;
+ if(methodNodes.has(n)){method=methodNodes.get(n);vars=new Map(cls.fields);collectVariables(unit,n,vars);owner=method.symbol}
+ if(n.name==='lambdaExpression'){vars=new Map(vars);for(const param of identifiers(n.children.lambdaParameters?.[0]))vars.set(param.image,null);owner=addSymbol(unit,n,(cls?.local||'')+'.lambda@'+n.location.startLine,'function')||owner}
+ if(cls&&['unannType','classType','interfaceType'].includes(n.name)){const type=resolveType(unit,text(unit,n),cls);if(type&&type.unit.path!==unit.path&&dependencies.length<MAX_EDGES)dependencies.push({source:unit.path,target:type.unit.path,specifier:type.fqn,line:n.location.startLine,kind:'java_type',resolution:'resolved'})}
+ if(cls&&n.name==='primary'){
+   const prefix=n.children.primaryPrefix?.[0],prefixText=text(unit,prefix).trim(),suffixes=n.children.primarySuffix||[];let chain=prefixText,fluent=false;
+   const newMatch=/^new\s+([\w.$]+)/.exec(prefixText);let constructed=newMatch?resolveType(unit,newMatch[1],cls):null;
+   if(constructed&&calls.length<MAX_EDGES)calls.push({source:(owner||cls.symbol).id,target:constructed.symbol.id,line:n.location.startLine,kind:'construct',resolution:'static'});
+   for(const suffix of suffixes){const invoke=suffix.children.methodInvocationSuffix?.[0];if(!invoke){chain+=text(unit,suffix);continue}const args=invoke.children.argumentList?.[0],arity=args?(args.children.expression||[]).length:0;const match=/^(?:([\w.$]+)\.)?([\w$]+)$/.exec(chain);let target=null;
+     if(match&&!fluent){const receiver=match[1],name=match[2];let type=null;if(!receiver||receiver==='this')type=cls;else if(receiver==='super')type=resolveType(unit,cls.extends,cls);else if(receiver.startsWith('this.'))type=resolveType(unit,cls.fields.get(receiver.slice(5))||'',cls);else if(vars.has(receiver))type=resolveType(unit,vars.get(receiver)||'',cls);else type=resolveType(unit,receiver,cls);target=lookupMethod(type,name,arity);if(!target&&!receiver){const candidates=unit.imports.filter(i=>i.static&&(i.spec.endsWith('.'+name)||i.spec.endsWith('.*'))).map(i=>lookupMethod(classes.get(i.spec.split('.').slice(0,-1).join('.')),name,arity)).filter(Boolean);if(candidates.length===1)target=candidates[0]}}
+     if(constructed&&!fluent){const methodName=/\.([\w$]+)$/.exec(chain)?.[1];if(methodName)target=lookupMethod(constructed,methodName,arity)}
+     if(target&&calls.length<MAX_EDGES)calls.push({source:(owner||cls.symbol).id,target:target.id,line:invoke.location.startLine,kind:'call',resolution:'static'});
+     else if(unresolved.length<1000)unresolved.push({path:unit.path,line:invoke.location.startLine,expression:chain.slice(0,140),reason:'External/dynamic type, interface without implementation, or ambiguous overload in the Java snapshot.'});
+     fluent=true;chain+='<result>';
+   }
+ }
+ for(const child of children(n))walk(child,cls,method,vars,owner)
+ }walk(unit.tree)
+}
+const ids=new Set(symbols.map(s=>s.id));
+process.stdout.write(JSON.stringify({symbols,dependencies:dependencies.slice(0,MAX_EDGES),calls:calls.filter(c=>ids.has(c.source)&&ids.has(c.target)),unresolved,diagnostics,parsed:units.map(u=>u.path),truncated:symbols.length>=MAX_SYMBOLS||dependencies.length>MAX_EDGES||calls.length>=MAX_EDGES}));

package/code_graph_js.cjs

@@ -0,0 +1,135 @@
+/* Análise estática de snapshots JS/TS. Não executa código nem lê arquivos do projeto. */
+const fs = require('node:fs');
+const path = require('node:path').posix;
+const ts = require('./web_adapters/node/node_modules/typescript');
+const input = JSON.parse(fs.readFileSync(0, 'utf8'));
+const clean = name => path.normalize(name.replaceAll('\\', '/')).replace(/^\.\//, '');
+const docs = new Map(input.files.map(f => ['/snapshot/' + clean(f.path), f]));
+const knownFiles = new Set([...docs.keys(),...(input.paths||[]).map(p=>'/snapshot/'+clean(p))]);
+const names = [...docs.keys()].filter(n => /\.(?:[cm]?[jt]s|[jt]sx)$/.test(n));
+const options = {allowJs:true, checkJs:true, jsx:ts.JsxEmit.Preserve, target:ts.ScriptTarget.Latest,
+  module:ts.ModuleKind.ESNext, moduleResolution:ts.ModuleResolutionKind.Bundler,
+  noLib:true, noEmit:true, skipLibCheck:true, allowImportingTsExtensions:true};
+let configPath = docs.has('/snapshot/tsconfig.json') ? '/snapshot/tsconfig.json' : '/snapshot/jsconfig.json';
+const configSeen = new Set();
+function readConfig(name, depth=0) {
+  if (depth>5 || configSeen.has(name) || !docs.has(name)) return {};
+  configSeen.add(name);
+  const raw = ts.parseConfigFileTextToJson(name, docs.get(name).text).config || {};
+  const base = typeof raw.extends==='string' && raw.extends.startsWith('.') ? readConfig(clean(path.join(path.dirname(name),raw.extends.endsWith('.json')?raw.extends:raw.extends+'.json')),depth+1) : {};
+  return {...base,...raw.compilerOptions};
+}
+const config=readConfig(configPath);
+const aliases=config.paths||{},baseUrl=clean(path.join(path.dirname(configPath),config.baseUrl||'.'));
+function candidate(base) {
+  const variants=[base,base.replace(/\.[cm]?jsx?$/,'.ts'),base.replace(/\.jsx?$/,'.tsx'),
+    ...['.ts','.tsx','.js','.jsx','.mts','.cts','.mjs','.cjs'].map(e=>base+e),
+    ...['.ts','.tsx','.js','.jsx'].map(e=>base+'/index'+e)];
+  return variants.find(name=>knownFiles.has(clean(name)));
+}
+function resolve(spec, from) {
+  if (spec.startsWith('.')) return candidate(clean(path.join(path.dirname(from),spec)));
+  for (const [pattern, targets] of Object.entries(aliases)) {
+    const [prefix,suffix='']=pattern.split('*');
+    if (pattern.includes('*') ? spec.startsWith(prefix)&&spec.endsWith(suffix) : spec===pattern) {
+      const middle=pattern.includes('*')?spec.slice(prefix.length,suffix? -suffix.length:undefined):'';
+      for (const target of Array.isArray(targets)?targets:[]) {
+        const found=candidate(clean(path.join(baseUrl,target.replace('*',middle))));
+        if(found)return found;
+      }
+    }
+  }
+  if(config.baseUrl)return candidate(clean(path.join(baseUrl,spec)));
+  return undefined;
+}
+const host={
+  getSourceFile:(name,version)=>docs.has(clean(name))?ts.createSourceFile(clean(name),docs.get(clean(name)).text,version,true):undefined,
+  getDefaultLibFileName:()=>'/lib.d.ts',writeFile:()=>{},getCurrentDirectory:()=>'/snapshot',
+  getDirectories:()=>[],fileExists:name=>docs.has(clean(name)),readFile:name=>docs.get(clean(name))?.text,
+  getCanonicalFileName:name=>clean(name),useCaseSensitiveFileNames:()=>true,getNewLine:()=> '\n',
+  resolveModuleNames:(modules,containing)=>modules.map(spec=>{const resolved=resolve(spec,containing);return resolved&&docs.has(resolved)&&/\.(?:[cm]?[jt]s|[jt]sx|json)$/.test(resolved)?{resolvedFileName:resolved,extension:ts.extensionFromPath(resolved),isExternalLibraryImport:false}:undefined;})
+};
+const program=ts.createProgram(names,options,host),checker=program.getTypeChecker();
+const symbols=[],dependencies=[],calls=[],unresolved=[],diagnostics=[],declarations=new Map(),moduleNodes=new Map();
+const maxSymbols=8000,maxEdges=20000;
+function filePath(source){return source.fileName.replace('/snapshot/','');}
+function line(source,pos){return source.getLineAndCharacterOfPosition(pos).line+1;}
+function displayName(node) {
+  if(node.name)return node.name.getText().replace(/^['"]|['"]$/g,'');
+  if(ts.isConstructorDeclaration(node))return 'constructor';
+  if(node.parent && ts.isVariableDeclaration(node.parent))return node.parent.name.getText();
+  if(node.parent && ts.isPropertyAssignment(node.parent))return node.parent.name.getText();
+  if(node.parent && ts.isPropertyDeclaration(node.parent))return node.parent.name.getText();
+  if(node.parent && ts.isExportAssignment(node.parent))return 'default';
+  return 'callback';
+}
+function isFunction(node){return !!node.body && (ts.isFunctionDeclaration(node)||ts.isMethodDeclaration(node)||ts.isFunctionExpression(node)||ts.isArrowFunction(node)||ts.isConstructorDeclaration(node)||ts.isGetAccessor(node)||ts.isSetAccessor(node));}
+function addSymbol(node,source,owner){
+  if(symbols.length>=maxSymbols)return null;
+  let name=displayName(node),parent=node.parent;
+  const classParent=parent&&ts.isPropertyDeclaration(parent)?parent.parent:parent;
+  const cls=classParent && (ts.isClassDeclaration(classParent)||ts.isClassExpression(classParent)) ? classParent.name?.getText() : null;
+  if(cls)name=cls+'.'+name;
+  const start=line(source,node.getStart(source)),id=filePath(source)+'::'+name+'@'+start+':'+node.pos;
+  const symbol={id,path:filePath(source),name,start_line:start,end_line:line(source,node.end),kind:cls?'method':'function',language:'typescript',parent:owner?.id||null};
+  symbols.push(symbol);declarations.set(node,symbol);return symbol;
+}
+const parsed=[];
+for(const source of program.getSourceFiles()){
+  if(!docs.has(source.fileName))continue;
+  if(source.parseDiagnostics.length){diagnostics.push({path:filePath(source),reason:'Incomplete or invalid syntax in the snapshot.',line:line(source,source.parseDiagnostics[0].start||0)});continue;}
+  parsed.push(source);
+  function collect(node,owner){const current=isFunction(node)?addSymbol(node,source,owner):owner;ts.forEachChild(node,child=>collect(child,current));}
+  collect(source,null);
+}
+function moduleSymbol(source){if(!moduleNodes.has(source.fileName)){const s={id:filePath(source)+'::<module>',path:filePath(source),name:'<module>',start_line:1,end_line:1,kind:'module',language:'typescript'};moduleNodes.set(source.fileName,s);symbols.push(s);}return moduleNodes.get(source.fileName);}
+function targetFor(node){
+  const signature=checker.getResolvedSignature(node);let target=declarations.get(signature?.declaration);
+  if(target)return target;
+  let symbol=checker.getSymbolAtLocation(node.expression);
+  if(symbol?.flags & ts.SymbolFlags.Alias)symbol=checker.getAliasedSymbol(symbol);
+  for(const declaration of symbol?.declarations||[]){
+    if(declarations.has(declaration))return declarations.get(declaration);
+    if(ts.isVariableDeclaration(declaration)&&declarations.has(declaration.initializer))return declarations.get(declaration.initializer);
+  }
+  return null;
+}
+for(const source of parsed){
+  function visit(node,owner){
+    if(isFunction(node) && !declarations.has(node))return;
+    const active=declarations.get(node)||owner;
+    if((ts.isImportDeclaration(node)||ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+      const spec=node.moduleSpecifier.text,target=resolve(spec,source.fileName);
+      if(dependencies.length<maxEdges)dependencies.push({source:filePath(source),target:target?.replace('/snapshot/','')||null,specifier:spec,line:line(source,node.getStart(source)),kind:node.importClause?.isTypeOnly||node.isTypeOnly?'type_import':'import',resolution:target?'resolved':spec.startsWith('.')?'unresolved':'external'});
+    }
+    if(ts.isCallExpression(node)||ts.isNewExpression(node)){
+      const expression=node.expression,at=line(source,node.getStart(source));
+      if(ts.isCallExpression(node) && (expression.kind===ts.SyntaxKind.ImportKeyword || ts.isIdentifier(expression)&&expression.text==='require') && node.arguments?.length && ts.isStringLiteral(node.arguments[0])){
+        const spec=node.arguments[0].text,target=resolve(spec,source.fileName);
+        if(dependencies.length<maxEdges)dependencies.push({source:filePath(source),target:target?.replace('/snapshot/','')||null,specifier:spec,line:at,kind:'dynamic_import',resolution:target?'resolved':spec.startsWith('.')?'unresolved':'external'});
+      }else{
+        const target=targetFor(node);
+        if(target && calls.length<maxEdges)calls.push({source:(active||moduleSymbol(source)).id,target:target.id,line:at,kind:ts.isNewExpression(node)?'construct':'call',resolution:'static'});
+        else if(unresolved.length<1000)unresolved.push({path:filePath(source),line:at,expression:expression.getText(source).slice(0,120),reason:'External or dynamic target, or no resolved implementation in the snapshot.'});
+      }
+    }
+    ts.forEachChild(node,child=>visit(child,active));
+  }
+  visit(source,null);
+}
+// Metadados Angular são lidos da AST; templates são analisados pelo compilador,
+// sem inicializar a aplicação, resolver DI em runtime ou executar seus decorators.
+const components=[],pipes=[],templatePaths=new Set();
+for(const source of parsed){
+ const angularAliases=new Map(),angularNamespaces=new Set();
+ for(const statement of source.statements){if(ts.isImportDeclaration(statement)&&statement.moduleSpecifier.text==='@angular/core'){const bindings=statement.importClause?.namedBindings;if(bindings&&ts.isNamedImports(bindings))for(const spec of bindings.elements)angularAliases.set(spec.name.text,(spec.propertyName||spec.name).text);else if(bindings&&ts.isNamespaceImport(bindings))angularNamespaces.add(bindings.name.text)}}
+ function visitClasses(node){if(ts.isClassDeclaration(node))for(const decorator of ts.canHaveDecorators(node)?ts.getDecorators(node)||[]:[]){const call=decorator.expression;if(!ts.isCallExpression(call)||!call.arguments.length||!ts.isObjectLiteralExpression(call.arguments[0]))continue;let type=null;if(ts.isIdentifier(call.expression)){const symbol=checker.getSymbolAtLocation(call.expression);if(symbol?.declarations?.some(ts.isImportSpecifier))type=angularAliases.get(call.expression.text)}else if(ts.isPropertyAccessExpression(call.expression)&&angularNamespaces.has(call.expression.expression.getText(source)))type=call.expression.name.text;if(!['Component','Pipe'].includes(type))continue;const metadata=new Map(call.arguments[0].properties.filter(ts.isPropertyAssignment).map(p=>[p.name.getText(source).replace(/^['"]|['"]$/g,''),p.initializer]));const methods=new Map();for(const member of node.members){const symbol=declarations.get(member)||declarations.get(member.initializer);if(symbol&&member.name)methods.set(member.name.getText(source).replace(/^['"]|['"]$/g,''),symbol)}const literal=n=>n&&ts.isStringLiteralLike(n)?n.text:null;const entry={source,node,name:node.name?.text||'<component>',methods,selector:literal(metadata.get('selector'))};if(type==='Pipe'){entry.pipeName=literal(metadata.get('name'));pipes.push(entry);continue}const template=metadata.get('template'),url=literal(metadata.get('templateUrl'));entry.template=literal(template);entry.templatePath=source.fileName;entry.inlineLine=template?line(source,template.getStart(source)):1;if(url){const target=resolve(url.startsWith('.')?url:'./'+url,source.fileName);entry.templatePath=target;entry.template=target?docs.get(target)?.text:null;entry.inlineLine=1;dependencies.push({source:filePath(source),target:target?.replace('/snapshot/','')||null,specifier:url,line:line(source,node.getStart(source)),kind:'angular_template',resolution:target?'resolved':'unresolved'})}for(const key of ['styleUrl','styleUrls']){const value=metadata.get(key),values=value&&ts.isArrayLiteralExpression(value)?value.elements:[value];for(const item of values){const style=literal(item);if(!style)continue;const target=resolve(style.startsWith('.')?style:'./'+style,source.fileName);dependencies.push({source:filePath(source),target:target?.replace('/snapshot/','')||null,specifier:style,line:line(source,item.getStart(source)),kind:'angular_style',resolution:target?'resolved':'unresolved'})}}components.push(entry)}ts.forEachChild(node,visitClasses)}visitClasses(source)
+}
+if(components.some(c=>c.template!=null)){
+ try{
+  const {parseTemplate}=require('./web_adapters/node/node_modules/@angular/compiler/fesm2022/compiler.mjs');
+  for(const component of components){if(component.template==null||!component.templatePath)continue;const pathName=component.templatePath.replace('/snapshot/',''),tree=parseTemplate(component.template,pathName);if(tree.errors?.length){diagnostics.push({path:pathName,reason:'Invalid Angular template or syntax not supported in this version.'});continue}templatePaths.add(pathName);const owner={id:pathName+'::'+filePath(component.source)+'::'+component.name+'.template@'+component.inlineLine,path:pathName,name:component.name+'.template',kind:'template',language:'angular',start_line:component.inlineLine,end_line:component.inlineLine+component.template.split('\n').length-1,location_kind:component.templatePath===component.source.fileName?'inline_template':'source_line'};if(symbols.length>=maxSymbols)break;symbols.push(owner);const shadow=new Set(),seen=new WeakSet();function walk(n,fn){if(!n||typeof n!=='object'||seen.has(n))return;seen.add(n);fn(n);for(const [key,value] of Object.entries(n)){if(['sourceSpan','span','startSourceSpan','endSourceSpan','keySpan','valueSpan','parent'].includes(key))continue;if(Array.isArray(value))value.forEach(x=>walk(x,fn));else if(value&&typeof value==='object')walk(value,fn)}}walk(tree.nodes,n=>{if(['Variable','Reference','LetDeclaration'].includes(n.constructor.name)&&n.name)shadow.add(n.name);if(n.constructor.name==='ForLoopBlock'&&n.item?.name)shadow.add(n.item.name)});const seen2=new WeakSet();function inspect(n){if(!n||typeof n!=='object'||seen2.has(n))return;seen2.add(n);const start=n.sourceSpan?.start,at=(typeof start==='number'?component.template.slice(0,start).split('\n').length-1:(start?.line??0))+component.inlineLine;if(n.constructor.name==='Call'||n.constructor.name==='SafeCall'){const receiver=n.receiver;if(receiver?.constructor.name==='PropertyRead'&&['ImplicitReceiver','ThisReceiver'].includes(receiver.receiver?.constructor.name)){const target=shadow.has(receiver.name)?null:component.methods.get(receiver.name);if(target&&calls.length<maxEdges)calls.push({source:owner.id,target:target.id,line:at,kind:'template_call',resolution:'static'});else if(unresolved.length<1000)unresolved.push({path:pathName,line:at,expression:receiver.name+'()',reason:'Unresolved template method, or a local variable that shadows the component.'})}}if(n.constructor.name==='Element'){const matches=components.filter(c=>c.selector===n.name);if(matches.length===1&&filePath(matches[0].source)!==pathName)dependencies.push({source:pathName,target:filePath(matches[0].source),specifier:n.name,line:at,kind:'angular_component',resolution:'resolved'})}if(n.constructor.name==='BindingPipe'){const matches=pipes.filter(p=>p.pipeName===n.name&&p.methods.has('transform'));if(matches.length===1){const pipe=matches[0];dependencies.push({source:pathName,target:filePath(pipe.source),specifier:n.name,line:at,kind:'angular_pipe',resolution:'resolved'});calls.push({source:owner.id,target:pipe.methods.get('transform').id,line:at,kind:'template_pipe',resolution:'static'})}}for(const [key,value] of Object.entries(n)){if(['sourceSpan','span','startSourceSpan','endSourceSpan','keySpan','valueSpan','parent'].includes(key))continue;if(Array.isArray(value))value.forEach(inspect);else if(value&&typeof value==='object')inspect(value)}}inspect(tree.nodes)
+  }
+ }catch{diagnostics.push({path:'Angular',reason:'The Angular template analyzer did not finish. Check the local runtime.'})}
+}
+process.stdout.write(JSON.stringify({symbols,dependencies:dependencies.slice(0,maxEdges),calls:calls.slice(0,maxEdges),unresolved,diagnostics,parsed:[...parsed.map(filePath),...templatePaths],truncated:symbols.length>=maxSymbols||calls.length>=maxEdges||dependencies.length>=maxEdges}));