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

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}));

package/config.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""Configuração de modelos do Smart Tool, compartilhada por todos os hosts MCP.
+
+Chaves de API ficam em `api_keys` sempre cifradas com DPAPI; texto em claro é recusado na gravação.
+"""
+import json
+import os
+import paths
+import threading
+
+import atomic_io
+import secret_store
+
+# Alias de compatibilidade: a implementação mora em `atomic_io`.
+atomic_replace = atomic_io.atomic_replace
+
+CONFIG_DIR = paths.HOME_DIR
+CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")
+
+# RLock: update_config() chama load/save sob o mesmo lock; Lock travaria a própria thread.
+_LOCK = threading.RLock()
+
+DEFAULT_CONFIG = {
+    "router_model": "",
+    "scope_model": "",
+    "embedding_model": "",
+    "rerank_model": "",
+    "research_model": "",
+    "research_max_iterations": 3,
+    "quick_search_timeout_s": 120,
+    "site_memory_similarity_threshold": 0.35,
+    "local_models": "fallback",
+    "hook_mode": "redirect",
+    "contact": "",
+    "model_adapter": "",
+    "model_adapter_options": {},
+}
+
+# Local models from the mcp-memory sidecar: fallback = only when the gateway has no model; off = never;
+# prefer = even when the gateway has one (embedding quality measured equal on the rerank gold set).
+LOCAL_MODEL_MODES = ("fallback", "off", "prefer")
+# PreToolUse hook: redirect = deny the native tool and point to Smart Tool; advise = let it run and add the tip to the
+# agent's context; off = no routing at all.
+HOOK_MODES = ("redirect", "advise", "off")
+
+
+def hook_mode(cfg=None):
+    value = (cfg if cfg is not None else load_config()).get("hook_mode") or DEFAULT_CONFIG["hook_mode"]
+    if value not in HOOK_MODES:
+        raise ValueError(f"Invalid hook_mode ({value!r}) in {CONFIG_PATH}: use redirect, advise or off.")
+    return value
+
+
+def local_models_mode(cfg=None):
+    value = (cfg if cfg is not None else load_config()).get("local_models") or DEFAULT_CONFIG["local_models"]
+    if value not in LOCAL_MODEL_MODES:
+        raise ValueError(f"Invalid local_models ({value!r}) in {CONFIG_PATH}: use fallback, off or prefer.")
+    return value
+
+
+# Único lugar com os limites/recomendados de research_max_iterations e
+# site_memory_similarity_threshold — configure.py, setup_ui.py e smart_tool_daemon.py leem
+# daqui em vez de cada um definir seu próprio intervalo (mesmo padrão de fonte única de
+# web_search_adapters.py pros tiers de busca).
+RESEARCH_MAX_ITERATIONS_RANGE = (1, 10)
+QUICK_SEARCH_TIMEOUT_RANGE = (30, 360)
+SITE_MEMORY_SIMILARITY_THRESHOLD_RANGE = (0.0, 1.0)
+WEB_PROVIDER_NAMES = ("exa", "parallel", "keenable", "tavily", "firecrawl")
+
+
+def _within(value, cast, bounds, key):
+    lo, hi = bounds
+    try:
+        n = cast(value)
+    except (TypeError, ValueError):
+        return DEFAULT_CONFIG[key]
+    return n if lo <= n <= hi else DEFAULT_CONFIG[key]
+
+
+def clamp_research_max_iterations(value):
+    return _within(value, int, RESEARCH_MAX_ITERATIONS_RANGE, "research_max_iterations")
+
+
+def clamp_quick_search_timeout(value):
+    return _within(value, int, QUICK_SEARCH_TIMEOUT_RANGE, "quick_search_timeout_s")
+
+
+def clamp_site_memory_similarity_threshold(value):
+    return _within(value, float, SITE_MEMORY_SIMILARITY_THRESHOLD_RANGE, "site_memory_similarity_threshold")
+
+
+class ConfigCorruptedError(Exception):
+    """O arquivo existe mas não é JSON de objeto legível. Distinto de "não existe":
+    `load_config()` pode cair pros defaults num arquivo ausente, mas gravar sobre
+    um arquivo ilegível apagaria configurações que ainda poderiam ser recuperadas."""
+
+
+def _read_stored():
+    try:
+        with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+            stored = json.load(f)
+    except FileNotFoundError:
+        return None
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise ConfigCorruptedError(
+            f"{CONFIG_PATH} is not valid JSON ({exc}); fix or delete the file manually."
+        )
+    if not isinstance(stored, dict):
+        raise ConfigCorruptedError(f"{CONFIG_PATH} does not contain a JSON object; fix or delete the file manually.")
+    return stored
+
+
+def load_config():
+    """Defaults mesclados com o que está em disco. Um arquivo corrompido devolve os
+    defaults em vez de levantar: leitura é caminho quente (todo tool call passa por
+    aqui) e não pode derrubar o daemon — quem for gravar usa `update_config`, que
+    recusa escrever nesse estado."""
+    with _LOCK:
+        try:
+            stored = _read_stored() or {}
+        except ConfigCorruptedError:
+            stored = {}
+        merged = dict(DEFAULT_CONFIG)
+        if "web_provider_keys" in stored:
+            raise ConfigCorruptedError(f"{CONFIG_PATH} uses the old 'web_provider_keys' format: delete that field and "
+                                       "enter the keys again in the setup screen.")
+        merged.update(stored)
+        return merged
+
+
+def save_config(config):
+    with _LOCK:
+        os.makedirs(CONFIG_DIR, exist_ok=True)
+        # Mantém o gravador atômico: a instalação antiga guardava segredo aqui.
+        clean = dict(config)
+        provider_keys = clean.get("api_keys") or {}
+        if (not isinstance(provider_keys, dict) or any(
+            not _known_key(name) or not secret_store.is_protected(value)
+            for name, value in provider_keys.items()
+        )):
+            raise ValueError("Keys must be protected by DPAPI.")
+        atomic_io.write_secret_text(
+            CONFIG_PATH, json.dumps(clean, indent=2, ensure_ascii=False)
+        )
+
+
+def corrupted_reason():
+    """Motivo pelo qual o arquivo em disco é ilegível, ou `None` se está legível/ausente.
+    `load_config` cai nos defaults nesse caso, então sem isto uma config truncada é
+    indistinguível de uma config vazia na hora de explicar a falha ao usuário."""
+    with _LOCK:
+        try:
+            _read_stored()
+        except ConfigCorruptedError as exc:
+            return str(exc)
+        return None
+
+
+def update_config(mutate):
+    """Load + mutate + save como uma única seção crítica, pra dois handlers HTTP
+    concorrentes nunca perderem a escrita um do outro. Levanta `ConfigCorruptedError`
+    se o arquivo em disco estiver ilegível, em vez de substituí-lo pelos defaults."""
+    with _LOCK:
+        stored = _read_stored() or {}
+        cfg = dict(DEFAULT_CONFIG)
+        cfg.update(stored)
+        # Serializado (não `dict(cfg)`): a comparação tem que enxergar mutação in-place
+        # de um valor aninhado, que uma cópia rasa esconderia. Mesmo contrato de
+        # serialização de `save_config`, pra um valor que só a comparação aceitaria não
+        # passar da guarda e estourar na gravação.
+        before = json.dumps(cfg, sort_keys=True)
+        mutate(cfg)
+        # Mutação que não muda nada não regrava.
+        if json.dumps(cfg, sort_keys=True) == before and os.path.isfile(CONFIG_PATH):
+            return cfg
+        save_config(cfg)
+        return cfg
+
+
+def _known_key(name):
+    """Web providers by name; model adapter secrets as "adapter:<adapter>:<field>" (see gateway.py)."""
+    return name in WEB_PROVIDER_NAMES or (isinstance(name, str) and name.startswith("adapter:"))
+
+
+def _provider_name(name):
+    if not _known_key(name):
+        raise ValueError(f"Unknown key: {name!r}")
+    return name
+
+
+def get_provider_api_key(name):
+    """Devolve a chave opcional em claro só no processo que fará a chamada HTTP."""
+    name = _provider_name(name)
+    stored = (load_config().get("api_keys") or {}).get(name) or ""
+    if not stored:
+        return ""
+    if not secret_store.is_protected(stored):
+        raise secret_store.SecretProtectionError("Provider key is not protected by DPAPI.")
+    return secret_store.unprotect(stored)
+
+
+def provider_key_status(name):
+    """Estado para a UI, sem revelar a chave nem o blob DPAPI."""
+    name = _provider_name(name)
+    stored = (load_config().get("api_keys") or {}).get(name) or ""
+    if not stored:
+        return "keyless"
+    try:
+        get_provider_api_key(name)
+    except secret_store.SecretProtectionError:
+        return "unreadable"
+    return "configured"
+
+
+def check_provider_key_format(key):
+    if len(key) > 4096 or any(ord(char) < 33 for char in key) or secret_store.is_protected(key):
+        raise ValueError("Paste the provider's original API key, without spaces or line breaks.")
+
+
+def set_provider_api_key(name, key):
+    """Grava/remove chave externa sob DPAPI; nunca persiste texto puro."""
+    name = _provider_name(name)
+    if key is not None and not isinstance(key, str):
+        raise ValueError("API key must be text.")
+    key = (key or "").strip()
+    if key:
+        check_provider_key_format(key)
+    protected = secret_store.protect(key) if key else ""
+
+    def mutate(cfg):
+        keys = dict(cfg.get("api_keys") or {})
+        if protected:
+            keys[name] = protected
+        else:
+            keys.pop(name, None)
+        if keys:
+            cfg["api_keys"] = keys
+        else:
+            cfg.pop("api_keys", None)
+
+    update_config(mutate)

package/daemon_launcher.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Lifecycle do daemon HTTP do Smart Tool: self-start com lock. Ao contrário do Brain
+Server (client-pure, nunca spawna, depende de instalador externo — o daemon que está
+caído neste ambiente por isso mesmo), este cliente sobe o processo sozinho se estiver
+fora do ar, protegido por lockfile contra corrida entre sessões simultâneas.
+
+Contrato de registry (mesmo formato usado pelo probe de grafo em `capabilities.py`):
+`~/.smart-tool/data/daemon.json` = `{"url": "http://127.0.0.1:<porta>"}` —
+`url` é a base do daemon; o endpoint MCP em si é `<url>/mcp`.
+"""
+import json
+import os
+import paths
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+RUN_DIR = paths.DATA_DIR
+REGISTRY_PATH = os.path.join(RUN_DIR, "daemon.json")
+LOCK_PATH = os.path.join(RUN_DIR, "daemon.lock")
+LOCK_STALE_SECONDS = 30
+DEFAULT_PORT = int(os.environ.get("SMART_TOOL_PORT", "8765"))
+DAEMON_SCRIPT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "smart_tool_daemon.py")
+
+
+def read_registry():
+    try:
+        with open(REGISTRY_PATH, "r", encoding="utf-8") as f:
+            info = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return None
+    if isinstance(info, dict) and info.get("url"):
+        return info
+    return None
+
+
+def health(url, timeout=1):
+    """Timeout curto porque só se fala com o loopback: um daemon vivo responde `/health`
+    em milissegundos (o servidor é multi-thread, indexação em curso não bloqueia), e o
+    caso lento é justamente o daemon morto cuja URL ainda está no registry — tempo que
+    toda tool call do agente paga antes de seguir."""
+    try:
+        with urllib.request.urlopen(url.rstrip("/") + "/health", timeout=timeout) as resp:
+            return resp.status == 200
+    except (urllib.error.URLError, OSError, ValueError):
+        return False
+
+
+def _acquire_lock():
+    os.makedirs(RUN_DIR, exist_ok=True)
+    try:
+        if time.time() - os.path.getmtime(LOCK_PATH) > LOCK_STALE_SECONDS:
+            os.remove(LOCK_PATH)
+    except OSError:
+        pass
+    try:
+        fd = os.open(LOCK_PATH, os.O_CREAT | os.O_EXCL | os.O_RDWR)
+        os.close(fd)
+        return True
+    except FileExistsError:
+        return False
+
+
+def _release_lock():
+    try:
+        os.remove(LOCK_PATH)
+    except OSError:
+        pass
+
+
+def _spawn_daemon():
+    executable = Path(sys.executable)
+    if sys.platform == "win32":
+        # O venv pythonw.exe pode morrer sem iniciar o daemon. O python.exe iniciado
+        # direto abre uma aba no Windows Terminal; fechá-la mata o serviço e o tray
+        # tenta subir outra a cada polling. WScript cria um processo independente com
+        # a janela oculta, como no Passtrough.
+        if executable.name.lower() == "pythonw.exe":
+            executable = executable.with_name("python.exe")
+        fd, launcher = tempfile.mkstemp(prefix="smart-tool-hidden-", suffix=".vbs")
+        try:
+            command = (f'Chr(34) & "{executable}" & Chr(34) & " " & '
+                       f'Chr(34) & "{DAEMON_SCRIPT}" & Chr(34)')
+            with os.fdopen(fd, "w", encoding="utf-16") as stream:
+                stream.write('Set sh = CreateObject("WScript.Shell")\n')
+                stream.write(f'sh.CurrentDirectory = "{Path(DAEMON_SCRIPT).parent}"\n')
+                stream.write(f'sh.Run {command}, 0, False\n')
+            result = subprocess.run(
+                ["wscript.exe", "//B", "//NoLogo", launcher],
+                stdin=subprocess.DEVNULL, capture_output=True, timeout=10,
+                creationflags=subprocess.CREATE_NO_WINDOW,
+            )
+            if result.returncode:
+                raise RuntimeError("Windows could not start the Smart Tool daemon without a window.")
+        finally:
+            Path(launcher).unlink(missing_ok=True)
+        return
+    subprocess.Popen(
+        [str(executable), DAEMON_SCRIPT],
+        stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL, close_fds=True, start_new_session=True,
+    )
+
+
+def ensure_daemon_running(wait_seconds=10):
+    """Retorna a URL base do daemon (sem `/mcp`), subindo o processo se necessário."""
+    info = read_registry()
+    if info and health(info["url"]):
+        return info["url"]
+
+    if not _acquire_lock():
+        url = _wait_for_daemon(wait_seconds)
+        if url:
+            return url
+        raise RuntimeError("Timed out waiting for another session to start the Smart Tool daemon")
+
+    try:
+        _spawn_daemon()
+        url = _wait_for_daemon(wait_seconds)
+        if url:
+            return url
+        raise RuntimeError("Timed out starting the Smart Tool daemon")
+    finally:
+        _release_lock()
+
+
+def daemon_url_if_up():
+    info = read_registry()
+    if info and health(info["url"], timeout=0.5):
+        return info["url"]
+    return None
+
+
+def start_daemon_if_down():
+    """`True` se o daemon já responde; `False` se acabou de disparar o start, sem esperar.
+
+    Para quem está num caminho sensível a latência (o hook PreToolUse roda antes de toda
+    Grep/Glob/Read/Bash): esperar o processo subir pode custar segundos — spawn de
+    processo em máquina com EDR varia muito — e quem chama tem um desfecho válido sem o
+    daemon. A garantia de daemon único não depende do lock ser mantido aqui: um segundo
+    processo falha no bind exclusivo da porta e morre sozinho."""
+    if daemon_url_if_up():
+        return True
+    if _acquire_lock():
+        # O lock NÃO é liberado aqui: ele é o freio de taxa. Expirando por idade
+        # (`LOCK_STALE_SECONDS`), um daemon que não consegue subir — porta tomada, import
+        # quebrado — resulta em uma tentativa a cada 30s, e não num processo órfão por
+        # tool call. Quem perde a corrida do bind morre sozinho (`allow_reuse_address`
+        # False), então soltar o lock não acrescentaria segurança nenhuma.
+        _spawn_daemon()
+    return False
+
+
+def _wait_for_daemon(wait_seconds, poll_interval=0.1):
+    deadline = time.time() + wait_seconds
+    while time.time() < deadline:
+        info = read_registry()
+        if info and health(info["url"], timeout=0.5):
+            return info["url"]
+        time.sleep(poll_interval)
+    return None