@octocodeai/octocode-tools-core 16.3.0 → 16.5.1

package/dist/shared/logger/logger.d.ts

@@ -0,0 +1,17 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    module: string;
+    message: string;
+    data?: Record<string, unknown>;
+}
+type LogHandler = (entry: LogEntry) => void;
+export declare function setLogHandler(handler: LogHandler | null): void;
+export declare function _getLogHandler(): LogHandler | null;
+export declare function createLogger(module: string): {
+    debug: (message: string, data?: Record<string, unknown>) => void;
+    info: (message: string, data?: Record<string, unknown>) => void;
+    warn: (message: string, data?: Record<string, unknown>) => void;
+    error: (message: string, data?: Record<string, unknown>) => void;
+};
+export {};

package/dist/shared/paths.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Octocode's home directory. Fixed per platform — there is no override env var:
+ *   - macOS:   `~/.octocode`
+ *   - Linux:   `${XDG_CONFIG_HOME:-~/.config}/.octocode`
+ *   - Windows: `%APPDATA%\.octocode`
+ */
+export declare function getDefaultOctocodeHome(): string;
+export declare const OCTOCODE_HOME: string;
+export declare const paths: {
+    readonly home: string;
+    readonly config: string;
+    readonly credentials: string;
+    readonly key: string;
+    readonly session: string;
+    readonly stats: string;
+    readonly tmp: string;
+    readonly clone: string;
+    readonly tree: string;
+    readonly binary: string;
+    readonly repos: string;
+    readonly logs: string;
+    readonly unzip: string;
+    readonly cliConfig: string;
+    readonly lspConfig: string;
+};
+export declare function ensureHome(): void;
+export declare function ensureRepos(): void;
+export declare function ensureTmp(): void;
+export declare function ensureClone(): void;
+export declare function ensureLogs(): void;
+export declare function ensureTree(): void;
+export declare function ensureBinary(): void;
+export declare function ensureUnzip(): void;

package/dist/shared/paths.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+import{existsSync as r,mkdirSync as n}from"node:fs";import{join as e}from"node:path";import p from"node:os";import x from"node:path";var c=p.platform()==="win32",f=p.platform()==="darwin",v=p.platform()==="linux",s=p.homedir();function m(){return c?process.env.APPDATA||x.join(s,"AppData","Roaming"):s}var d=".octocode",i=448;function A(g){let a=process.env[g];return a&&a.trim().length>0?a:void 0}function h(){return c?e(m(),d):f?e(s,d):e(A("XDG_CONFIG_HOME")??e(s,".config"),d)}var o=h(),t={home:o,config:e(o,".octocoderc"),credentials:e(o,"credentials.json"),key:e(o,".key"),session:e(o,"session.json"),stats:e(o,"stats.json"),tmp:e(o,"tmp"),clone:e(o,"tmp","clone"),tree:e(o,"tmp","tree"),binary:e(o,"tmp","binary"),repos:e(o,"tmp","clone"),logs:e(o,"logs"),unzip:e(o,"tmp","unzip"),cliConfig:e(o,"config.json"),lspConfig:e(o,"lsp-servers.json")};function l(){r(t.home)||n(t.home,{recursive:!0,mode:i})}function z(){D()}function u(){l(),r(t.tmp)||n(t.tmp,{recursive:!0,mode:i})}function D(){u(),r(t.clone)||n(t.clone,{recursive:!0,mode:i})}function N(){l(),r(t.logs)||n(t.logs,{recursive:!0,mode:i})}function T(){u(),r(t.tree)||n(t.tree,{recursive:!0,mode:i})}function _(){u(),r(t.binary)||n(t.binary,{recursive:!0,mode:i})}function R(){u(),r(t.unzip)||n(t.unzip,{recursive:!0,mode:i})}export{o as OCTOCODE_HOME,_ as ensureBinary,D as ensureClone,l as ensureHome,N as ensureLogs,z as ensureRepos,u as ensureTmp,T as ensureTree,R as ensureUnzip,h as getDefaultOctocodeHome,t as paths};

package/dist/shared/platform/index.d.ts

@@ -0,0 +1 @@
+export { isWindows, isMac, isLinux, HOME, getAppDataPath, getLocalAppDataPath, getPlatformName, getArchitecture, } from './platform.js';

package/dist/shared/platform/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+import t from"node:os";import n from"node:path";var o=t.platform()==="win32",e=t.platform()==="darwin",a=t.platform()==="linux",r=t.homedir();function i(){return o?process.env.APPDATA||n.join(r,"AppData","Roaming"):r}function p(){return o?process.env.LOCALAPPDATA||n.join(r,"AppData","Local"):r}function s(){return e?"macOS":o?"Windows":a?"Linux":t.platform()}function c(){return t.arch()}export{r as HOME,i as getAppDataPath,c as getArchitecture,p as getLocalAppDataPath,s as getPlatformName,a as isLinux,e as isMac,o as isWindows};

package/dist/shared/platform/platform.d.ts

@@ -0,0 +1,8 @@
+export declare const isWindows: boolean;
+export declare const isMac: boolean;
+export declare const isLinux: boolean;
+export declare const HOME: string;
+export declare function getAppDataPath(): string;
+export declare function getLocalAppDataPath(): string;
+export declare function getPlatformName(): string;
+export declare function getArchitecture(): string;

package/dist/shared/session/index.d.ts

@@ -0,0 +1,5 @@
+export type { GitHubCacheHitStats, PersistedStats, PersistedSession, SessionStats, SessionTotalUsageStats, SessionUpdateResult, SessionOptions, StatsCounterMap, ToolCharSavingsStats, } from './types.js';
+export { SESSION_FILE, STATS_FILE } from './storage.js';
+export { readSession, writeSession, getOrCreateSession, getSessionId, deleteSession, flushSession, flushSessionSync, } from './storage.js';
+export { updateSessionStats, incrementToolCalls, incrementErrors, incrementRateLimits, incrementRateLimitByProvider, incrementToolCharSavings, incrementGitHubCacheHits, incrementGitHubCacheRateLimits, incrementPackageRegistryFailures, resetSessionStats, } from './storage.js';
+export { _resetSessionState } from './storage.js';

package/dist/shared/session/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from 'module';
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+import{randomUUID as kt}from"node:crypto";import{existsSync as Z,readFileSync as Re,writeFileSync as lt,unlinkSync as ft,renameSync as dt}from"node:fs";var He=null;function Oe(e){let t=`[${e.module}]`,r=e.data&&Object.keys(e.data).length>0?` ${JSON.stringify(e.data)}`:"";process.stderr.write(`${t} ${e.level}: ${e.message}${r}
+`)}function S(e){function t(r,s,n){let i={level:r,module:e,message:s,...n&&{data:n}};(He??Oe)(i)}return{debug:(r,s)=>t("debug",r,s),info:(r,s)=>t("info",r,s),warn:(r,s)=>t("warn",r,s),error:(r,s)=>t("error",r,s)}}function g(e){return e.toLowerCase().replace(/^https?:\/\//,"").replace(/\/$/,"")}function w(e){if(!e.token.expiresAt)return!1;let t=new Date(e.token.expiresAt);if(isNaN(t.getTime()))return!0;let r=new Date;return t.getTime()-r.getTime()<300*1e3}function W(e){if(!e.token.refreshTokenExpiresAt)return!1;let t=new Date(e.token.refreshTokenExpiresAt);return isNaN(t.getTime())?!0:new Date>=t}var A=new Map,De=300*1e3;function _e(e){let t=g(e),r=A.get(t);return!r||Date.now()-r.cachedAt>=De?!1:r.credentials?!w(r.credentials):!0}function te(e){e?A.delete(g(e)):A.clear()}function re(e){let t=g(e);if(_e(t))return A.get(t).credentials}function se(e,t){let r=g(e);A.set(r,{credentials:t,cachedAt:Date.now()})}import{existsSync as ae,readFileSync as ce,writeFileSync as ue,unlinkSync as lr,statSync as We,chmodSync as $e}from"node:fs";import{createCipheriv as Ke,createDecipheriv as Ve,randomBytes as le}from"node:crypto";import{existsSync as Ne,mkdirSync as Ge}from"node:fs";import{join as a}from"node:path";import N from"node:os";import Fe from"node:path";var G=N.platform()==="win32",$=N.platform()==="darwin",Ie=N.platform()==="linux",y=N.homedir();function K(){return G?process.env.APPDATA||Fe.join(y,"AppData","Roaming"):y}var V=".octocode",Me=448;function je(e){let t=process.env[e];return t&&t.trim().length>0?t:void 0}function Ue(){return G?a(K(),V):$?a(y,V):a(je("XDG_CONFIG_HOME")??a(y,".config"),V)}var u=Ue(),f={home:u,config:a(u,".octocoderc"),credentials:a(u,"credentials.json"),key:a(u,".key"),session:a(u,"session.json"),stats:a(u,"stats.json"),tmp:a(u,"tmp"),clone:a(u,"tmp","clone"),tree:a(u,"tmp","tree"),binary:a(u,"tmp","binary"),repos:a(u,"tmp","clone"),logs:a(u,"logs"),unzip:a(u,"tmp","unzip"),cliConfig:a(u,"config.json"),lspConfig:a(u,"lsp-servers.json")};function ne(){Ne(f.home)||Ge(f.home,{recursive:!0,mode:Me})}import{z as c}from"zod";var Be=c.object({token:c.string(),tokenType:c.literal("oauth"),scopes:c.array(c.string()).optional(),refreshToken:c.string().optional(),expiresAt:c.string().optional(),refreshTokenExpiresAt:c.string().optional()}),ze=c.object({hostname:c.string(),username:c.string(),token:Be,gitProtocol:c.enum(["ssh","https"]),createdAt:c.string(),updatedAt:c.string()}),oe=c.object({version:c.number(),credentials:c.record(c.string(),ze)});var ie=S("token-storage");function Je(e){return e.replace(/\b(ghp_|gho_|ghu_|ghs_|ghr_)[a-zA-Z0-9]{36,}\b/g,"***MASKED***").replace(/\b[a-zA-Z0-9]{40,}\b/g,"***MASKED***")}var Ze=f.home,R=f.credentials,v=f.key,fe="aes-256-gcm",qe=16;function b(){ne()}function de(){if(b(),ae(v))return We(v).mode&511&63&&$e(v,384),Buffer.from(ce(v,"utf8"),"hex");let e=le(32);return ue(v,e.toString("hex"),{mode:384}),e}function pe(e){let t=de(),r=le(qe),s=Ke(fe,t,r),n=s.update(e,"utf8","hex");n+=s.final("hex");let i=s.getAuthTag();return`${r.toString("hex")}:${i.toString("hex")}:${n}`}function me(e){let t=de(),[r,s,n]=e.split(":");if(!r||!s||!n)throw new Error("Invalid encrypted data format");let i=Buffer.from(r,"hex"),x=Buffer.from(s,"hex"),m=Ve(fe,t,i);m.setAuthTag(x);let ee=m.update(n,"hex","utf8");return ee+=m.final("utf8"),ee}function J(){if(b(),!ae(R))return{version:1,credentials:{}};try{let e=ce(R,"utf8"),t=me(e),r=JSON.parse(t),s=oe.safeParse(r);return s.success?s.data:(ie.warn("Credentials file has invalid format \u2014 starting fresh",{file:R}),{version:1,credentials:{}})}catch(e){let t=e instanceof Error&&e.message?Je(e.message):void 0;return ie.warn("Could not read credentials file \u2014 you may need to login again",{file:R,...t&&{reason:t}}),{version:1,credentials:{}}}}function ge(e){b();let t=pe(JSON.stringify(e,null,2));ue(R,t,{mode:384})}import{refreshToken as Ye}from"@octokit/oauth-methods";import{request as Xe}from"@octokit/request";var M="178c6fc778ccc68e1d6a",P="github.com";function Qe(e){return e.replace(/\b(ghp_|gho_|ghu_|ghs_|ghr_)[a-zA-Z0-9]{36,}\b/g,"***MASKED***").replace(/\b[a-zA-Z0-9]{40,}\b/g,"***MASKED***")}function et(e){return e==="github.com"||e===P?"https://api.github.com":`https://${e}/api/v3`}async function he(e,t=P,r=M){let s=await e.getCredentials(t);if(!s)return{success:!1,error:`Not logged in to ${t}`};if(!s.token.refreshToken)return{success:!1,error:"Token does not support refresh (OAuth App tokens do not expire)"};if(W(s))return{success:!1,error:"Refresh token has expired. Please login again."};try{let n=await Ye({clientType:"github-app",clientId:r,clientSecret:"",refreshToken:s.token.refreshToken,request:Xe.defaults({baseUrl:et(t)})}),i={token:n.authentication.token,tokenType:"oauth",refreshToken:n.authentication.refreshToken,expiresAt:n.authentication.expiresAt,refreshTokenExpiresAt:n.authentication.refreshTokenExpiresAt};return await e.updateToken(t,i),{success:!0,username:s.username,hostname:t}}catch(n){return{success:!1,error:n instanceof Error?Qe(n.message):"Token refresh failed"}}}async function Se(e,t=P,r=M){let s=await e.getCredentials(t);if(!s||!s.token)return{token:null,source:"none"};if(!w(s))return{token:s.token.token,source:"stored",username:s.username};if(s.token.refreshToken){let n=await he(e,t,r);if(n.success){let i=await e.getCredentials(t);if(i?.token.token)return{token:i.token.token,source:"refreshed",username:i.username}}return{token:null,source:"none",refreshError:n.error}}return{token:null,source:"none",refreshError:"Token expired and no refresh token available"}}import{execFile as Rr}from"child_process";var tt=null;function Ce(e){tt=e}var rt=S("token-storage");async function st(e){let t=g(e.hostname),r={...e,hostname:t,updatedAt:new Date().toISOString()};try{let s=J();return s.credentials[t]=r,ge(s),te(t),{success:!0}}catch(s){let n=s instanceof Error?s.message:String(s);throw rt.error("CRITICAL: Storage failed",{error:n.replace(/\b(ghp_|gho_|ghu_|ghs_|ghr_)[a-zA-Z0-9]{36,}\b/g,"***MASKED***").replace(/\b[a-zA-Z0-9]{40,}\b/g,"***MASKED***")}),new Error("Failed to store credentials")}}async function ke(e="github.com",t){let r=g(e);if(!t?.bypassCache){let i=re(r);if(i!==void 0)return i}let n=J().credentials[r]||null;return se(r,n),n}async function nt(e,t){let r=await ke(e);return r?(r.token=t,r.updatedAt=new Date().toISOString(),await st(r),!0):!1}async function ot(e,t){return Se({getCredentials:ke,updateToken:nt},e,t)}Ce({getTokenWithRefresh:ot});import{z as o}from"zod";var it=o.object({rawChars:o.number(),responseChars:o.number(),savedChars:o.number(),calls:o.number()}),at=o.object({hits:o.record(o.string(),o.number()).default({}),rateLimits:o.number().default(0)}),j=o.record(o.string(),o.number()).default({}),ct=o.object({toolCalls:o.number(),errors:o.number(),rateLimits:o.number(),rateLimitsByProvider:j,rawChars:o.number(),responseChars:o.number(),savedChars:o.number(),charSavingsCalls:o.number(),githubCacheHits:o.number(),githubCacheRateLimits:o.number(),packageRegistryFailures:o.number().default(0),packageRegistryFailuresByRegistry:j}),U=o.object({toolCalls:o.number(),errors:o.number(),rateLimits:o.number(),rateLimitsByProvider:j,charsSavedByTool:o.record(o.string(),it).default({}),githubCacheHits:at.default({hits:{},rateLimits:0}),packageRegistryFailures:j,totalUsage:ct.optional()}),Te=o.object({version:o.literal(1),sessionId:o.string(),createdAt:o.string(),lastActiveAt:o.string(),stats:U.optional()}),xe=o.object({version:o.literal(1),stats:U});function ye(e){return Object.values(e).reduce((t,r)=>t+r,0)}function ut(e){let t=e.charsSavedByTool??{},r=e.githubCacheHits??{hits:{},rateLimits:0},s=e.rateLimitsByProvider??{},n=e.packageRegistryFailures??{},i=Object.values(t).reduce((x,m)=>({rawChars:x.rawChars+m.rawChars,responseChars:x.responseChars+m.responseChars,savedChars:x.savedChars+m.savedChars,charSavingsCalls:x.charSavingsCalls+m.calls}),{rawChars:0,responseChars:0,savedChars:0,charSavingsCalls:0});return{toolCalls:e.toolCalls,errors:e.errors,rateLimits:e.rateLimits,rateLimitsByProvider:s,...i,githubCacheHits:ye(r.hits),githubCacheRateLimits:r.rateLimits,packageRegistryFailures:ye(n),packageRegistryFailuresByRegistry:n}}function d(e){let t={...e,rateLimitsByProvider:e.rateLimitsByProvider??{},charsSavedByTool:e.charsSavedByTool??{},githubCacheHits:e.githubCacheHits??{hits:{},rateLimits:0},packageRegistryFailures:e.packageRegistryFailures??{}};return{...t,totalUsage:ut(t)}}function H(){return d({toolCalls:0,errors:0,rateLimits:0,rateLimitsByProvider:{},charsSavedByTool:{},githubCacheHits:{hits:{},rateLimits:0},packageRegistryFailures:{}})}var be=S("session"),C=f.session,k=f.stats;function ve(e,t){let r=`${e}.tmp`;lt(r,JSON.stringify(t,null,2),{mode:384}),dt(r,e)}function pt(e){let{stats:t,...r}=e;return r}function mt(e){let t=JSON.parse(e),r=xe.safeParse(t);if(r.success)return d(r.data.stats);let s=U.safeParse(t);return s.success?d(s.data):null}function gt(e){let t=e?d(e):H();if(!Z(k))return t;try{let r=Re(k,"utf8"),s=mt(r);return s||(be.warn("Stats file has invalid format",{file:k}),t)}catch{return t}}function B(e){b(),ve(k,{version:e.version,stats:d(e.stats)}),ve(C,pt(e))}function Ee(){if(!Z(C))return null;try{let e=Re(C,"utf8"),t=JSON.parse(e),r=Te.safeParse(t);return r.success?{...r.data,stats:gt(r.data.stats)}:(be.warn("Session file has invalid format",{file:C}),null)}catch{return null}}function Le(){let e=!1;for(let t of[C,k])if(Z(t))try{ft(t),e=!0}catch{return!1}return e}var ht=6e4,l=null,h=!1,E=null,q=!1,O=null,D=null,_=null,z=!1;function St(){q||(q=!0,O=()=>{F()},D=()=>{F()},_=()=>{F()},process.on("exit",O),process.on("SIGINT",D),process.on("SIGTERM",_))}function Y(){O&&(process.removeListener("exit",O),O=null),D&&(process.removeListener("SIGINT",D),D=null),_&&(process.removeListener("SIGTERM",_),_=null),q=!1}function Ct(){E||(E=setInterval(()=>{h&&l&&(B(l),h=!1)},ht),E.unref())}function X(){E&&(clearInterval(E),E=null)}function L(){if(l)return l;let e=Ee();return e&&(l=e),e}function T(e){l=e,h=!0,St(),Ct()}function I(){h&&l&&(B(l),h=!1)}function F(){if(!z&&h&&l){z=!0;try{B(l),h=!1}catch{}finally{z=!1}}}function Q(){l=null,h=!1,z=!1}function we(){Q(),X(),Y()}var Tt=1;function xt(e){return d(e)}function yt(e,t){if(!t)return e;let r={...e};for(let[s,n]of Object.entries(t)){let i=r[s]??{rawChars:0,responseChars:0,savedChars:0,calls:0};r[s]={rawChars:i.rawChars+n.rawChars,responseChars:i.responseChars+n.responseChars,savedChars:i.savedChars+n.savedChars,calls:i.calls+n.calls}}return r}function Ae(e,t){if(!t)return e;let r={...e};for(let[s,n]of Object.entries(t))r[s]=(r[s]??0)+n;return r}function vt(e,t){if(!t)return e;let r={...e.hits};for(let[s,n]of Object.entries(t.hits??{}))r[s]=(r[s]??0)+n;return{hits:r,rateLimits:e.rateLimits+(t.rateLimits??0)}}function Pe(){let e=new Date().toISOString();return{version:Tt,sessionId:kt(),createdAt:e,lastActiveAt:e,stats:H()}}function Rt(){return L()}function bt(e){T(e)}function Et(){I()}function Lt(){F()}function wt(e){if(e?.forceNew){let s=Pe();return T(s),I(),s}let t=L();if(t){let s={...t,lastActiveAt:new Date().toISOString()};return T(s),I(),s}let r=Pe();return T(r),I(),r}function At(){return L()?.sessionId??null}function p(e){let t=L();if(!t)return{success:!1,session:null};let r=xt(t.stats),s=d({toolCalls:r.toolCalls+(e.toolCalls??0),errors:r.errors+(e.errors??0),rateLimits:r.rateLimits+(e.rateLimits??0),rateLimitsByProvider:Ae(r.rateLimitsByProvider,e.rateLimitsByProvider),charsSavedByTool:yt(r.charsSavedByTool,e.charsSavedByTool),githubCacheHits:vt(r.githubCacheHits,e.githubCacheHits),packageRegistryFailures:Ae(r.packageRegistryFailures,e.packageRegistryFailures)}),n={...t,lastActiveAt:new Date().toISOString(),stats:s};return T(n),{success:!0,session:n}}function Pt(e=1){return p({toolCalls:e})}function Ht(e=1){return p({errors:e})}function Ot(e=1){return p({rateLimits:e})}function Dt(e,t=1){return p({rateLimits:t,rateLimitsByProvider:{[e]:t}})}function _t(e,t,r){let s=Number.isFinite(t)?Math.max(0,t):0,n=Number.isFinite(r)?Math.max(0,r):0;return p({charsSavedByTool:{[e]:{rawChars:s,responseChars:n,savedChars:Math.max(0,s-n),calls:1}}})}function Ft(e,t=1){return p({githubCacheHits:{hits:{[e]:t},rateLimits:0}})}function It(e=1){return p({githubCacheHits:{hits:{},rateLimits:e}})}function Nt(e,t=1){return p({packageRegistryFailures:{[e]:t}})}function Gt(){let e=L();if(!e)return{success:!1,session:null};let t={...e,lastActiveAt:new Date().toISOString(),stats:H()};return T(t),{success:!0,session:t}}function Mt(){return Q(),X(),Y(),Le()}function jt(){we()}export{C as SESSION_FILE,k as STATS_FILE,jt as _resetSessionState,Mt as deleteSession,Et as flushSession,Lt as flushSessionSync,wt as getOrCreateSession,At as getSessionId,Ht as incrementErrors,Ft as incrementGitHubCacheHits,It as incrementGitHubCacheRateLimits,Nt as incrementPackageRegistryFailures,Dt as incrementRateLimitByProvider,Ot as incrementRateLimits,Pt as incrementToolCalls,_t as incrementToolCharSavings,Rt as readSession,Gt as resetSessionStats,p as updateSessionStats,bt as writeSession};

package/dist/shared/session/schemas.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const SessionStatsSchema: z.ZodObject<{
+    toolCalls: z.ZodNumber;
+    errors: z.ZodNumber;
+    rateLimits: z.ZodNumber;
+    rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    charsSavedByTool: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        rawChars: z.ZodNumber;
+        responseChars: z.ZodNumber;
+        savedChars: z.ZodNumber;
+        calls: z.ZodNumber;
+    }, z.core.$strip>>>;
+    githubCacheHits: z.ZodDefault<z.ZodObject<{
+        hits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        rateLimits: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    packageRegistryFailures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    totalUsage: z.ZodOptional<z.ZodObject<{
+        toolCalls: z.ZodNumber;
+        errors: z.ZodNumber;
+        rateLimits: z.ZodNumber;
+        rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        rawChars: z.ZodNumber;
+        responseChars: z.ZodNumber;
+        savedChars: z.ZodNumber;
+        charSavingsCalls: z.ZodNumber;
+        githubCacheHits: z.ZodNumber;
+        githubCacheRateLimits: z.ZodNumber;
+        packageRegistryFailures: z.ZodDefault<z.ZodNumber>;
+        packageRegistryFailuresByRegistry: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const PersistedSessionSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    createdAt: z.ZodString;
+    lastActiveAt: z.ZodString;
+    stats: z.ZodOptional<z.ZodObject<{
+        toolCalls: z.ZodNumber;
+        errors: z.ZodNumber;
+        rateLimits: z.ZodNumber;
+        rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        charsSavedByTool: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            rawChars: z.ZodNumber;
+            responseChars: z.ZodNumber;
+            savedChars: z.ZodNumber;
+            calls: z.ZodNumber;
+        }, z.core.$strip>>>;
+        githubCacheHits: z.ZodDefault<z.ZodObject<{
+            hits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            rateLimits: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        packageRegistryFailures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        totalUsage: z.ZodOptional<z.ZodObject<{
+            toolCalls: z.ZodNumber;
+            errors: z.ZodNumber;
+            rateLimits: z.ZodNumber;
+            rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            rawChars: z.ZodNumber;
+            responseChars: z.ZodNumber;
+            savedChars: z.ZodNumber;
+            charSavingsCalls: z.ZodNumber;
+            githubCacheHits: z.ZodNumber;
+            githubCacheRateLimits: z.ZodNumber;
+            packageRegistryFailures: z.ZodDefault<z.ZodNumber>;
+            packageRegistryFailuresByRegistry: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const PersistedStatsSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    stats: z.ZodObject<{
+        toolCalls: z.ZodNumber;
+        errors: z.ZodNumber;
+        rateLimits: z.ZodNumber;
+        rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        charsSavedByTool: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            rawChars: z.ZodNumber;
+            responseChars: z.ZodNumber;
+            savedChars: z.ZodNumber;
+            calls: z.ZodNumber;
+        }, z.core.$strip>>>;
+        githubCacheHits: z.ZodDefault<z.ZodObject<{
+            hits: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            rateLimits: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        packageRegistryFailures: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        totalUsage: z.ZodOptional<z.ZodObject<{
+            toolCalls: z.ZodNumber;
+            errors: z.ZodNumber;
+            rateLimits: z.ZodNumber;
+            rateLimitsByProvider: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            rawChars: z.ZodNumber;
+            responseChars: z.ZodNumber;
+            savedChars: z.ZodNumber;
+            charSavingsCalls: z.ZodNumber;
+            githubCacheHits: z.ZodNumber;
+            githubCacheRateLimits: z.ZodNumber;
+            packageRegistryFailures: z.ZodDefault<z.ZodNumber>;
+            packageRegistryFailuresByRegistry: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/shared/session/sessionCache.d.ts

@@ -0,0 +1,9 @@
+import type { PersistedSession } from './types.js';
+export declare function unregisterExitHandlers(): void;
+export declare function stopFlushTimer(): void;
+export declare function readSession(): PersistedSession | null;
+export declare function writeSession(session: PersistedSession): void;
+export declare function flushSession(): void;
+export declare function flushSessionSync(): void;
+export declare function clearCache(): void;
+export declare function resetCacheState(): void;

package/dist/shared/session/sessionDiskIO.d.ts

@@ -0,0 +1,6 @@
+import type { PersistedSession } from './types.js';
+export declare const SESSION_FILE: string;
+export declare const STATS_FILE: string;
+export declare function writeSessionToDisk(session: PersistedSession): void;
+export declare function readSessionFromDisk(): PersistedSession | null;
+export declare function deleteSessionFile(): boolean;

package/dist/shared/session/statsDefaults.d.ts

@@ -0,0 +1,4 @@
+import type { SessionStats, SessionTotalUsageStats } from './types.js';
+export declare function calculateTotalUsageStats(stats: SessionStats): SessionTotalUsageStats;
+export declare function withDerivedUsageTotals(stats: SessionStats): SessionStats;
+export declare function createDefaultStats(): SessionStats;

package/dist/shared/session/storage.d.ts

@@ -0,0 +1,20 @@
+import type { PersistedSession, SessionStats, SessionUpdateResult, SessionOptions } from './types.js';
+export declare function readSession(): PersistedSession | null;
+export declare function writeSession(session: PersistedSession): void;
+export declare function flushSession(): void;
+export declare function flushSessionSync(): void;
+export declare function getOrCreateSession(options?: SessionOptions): PersistedSession;
+export declare function getSessionId(): string | null;
+export declare function updateSessionStats(updates: Partial<SessionStats>): SessionUpdateResult;
+export declare function incrementToolCalls(count?: number): SessionUpdateResult;
+export declare function incrementErrors(count?: number): SessionUpdateResult;
+export declare function incrementRateLimits(count?: number): SessionUpdateResult;
+export declare function incrementRateLimitByProvider(provider: string, count?: number): SessionUpdateResult;
+export declare function incrementToolCharSavings(toolName: string, rawChars: number, responseChars: number): SessionUpdateResult;
+export declare function incrementGitHubCacheHits(cacheName: string, count?: number): SessionUpdateResult;
+export declare function incrementGitHubCacheRateLimits(count?: number): SessionUpdateResult;
+export declare function incrementPackageRegistryFailures(registry: string, count?: number): SessionUpdateResult;
+export declare function resetSessionStats(): SessionUpdateResult;
+export declare function deleteSession(): boolean;
+export declare function _resetSessionState(): void;
+export { SESSION_FILE, STATS_FILE } from './sessionDiskIO.js';

package/dist/shared/session/types.d.ts

@@ -0,0 +1,53 @@
+export interface ToolCharSavingsStats {
+    rawChars: number;
+    responseChars: number;
+    savedChars: number;
+    calls: number;
+}
+export interface GitHubCacheHitStats {
+    hits: Record<string, number>;
+    rateLimits: number;
+}
+export type StatsCounterMap = Record<string, number>;
+export interface SessionTotalUsageStats {
+    toolCalls: number;
+    errors: number;
+    rateLimits: number;
+    rateLimitsByProvider: StatsCounterMap;
+    rawChars: number;
+    responseChars: number;
+    savedChars: number;
+    charSavingsCalls: number;
+    githubCacheHits: number;
+    githubCacheRateLimits: number;
+    packageRegistryFailures: number;
+    packageRegistryFailuresByRegistry: StatsCounterMap;
+}
+export interface SessionStats {
+    toolCalls: number;
+    errors: number;
+    rateLimits: number;
+    rateLimitsByProvider?: StatsCounterMap;
+    charsSavedByTool?: Record<string, ToolCharSavingsStats>;
+    githubCacheHits?: GitHubCacheHitStats;
+    packageRegistryFailures?: StatsCounterMap;
+    totalUsage?: SessionTotalUsageStats;
+}
+export interface PersistedSession {
+    version: 1;
+    sessionId: string;
+    createdAt: string;
+    lastActiveAt: string;
+    stats: SessionStats;
+}
+export interface PersistedStats {
+    version: 1;
+    stats: SessionStats;
+}
+export interface SessionUpdateResult {
+    success: boolean;
+    session: PersistedSession | null;
+}
+export interface SessionOptions {
+    forceNew?: boolean;
+}

package/dist/tools/github_clone_repo/cache.d.ts

@@ -1,6 +1,9 @@
 import type { CloneCacheMeta, CacheSource } from './types.js';
 export declare function getReposBaseDir(octocodeDir: string): string;
+export declare function getCloneBaseDir(octocodeDir: string): string;
+export declare function getTreeBaseDir(octocodeDir: string): string;
 export declare function getCloneDir(octocodeDir: string, owner: string, repo: string, branch: string, sparsePath?: string): string;
+export declare function getTreeDir(octocodeDir: string, owner: string, repo: string, branch: string): string;
 export declare function readCacheMeta(cloneDir: string): CloneCacheMeta | null;
 export declare function writeCacheMeta(cloneDir: string, meta: CloneCacheMeta): void;
 export declare function isCacheValid(meta: CloneCacheMeta): boolean;
@@ -17,5 +20,6 @@ export declare function createCacheMeta(owner: string, repo: string, branch: str
 export declare function ensureCloneParentDir(cloneDir: string): void;
 export declare function removeCloneDir(cloneDir: string): void;
 export declare function evictExpiredClones(octocodeDir: string): number;
+export declare function evictExpiredTrees(octocodeDir: string): number;
 export declare function startCacheGC(octocodeDir: string): void;
 export declare function stopCacheGC(): void;

package/dist/tools/github_clone_repo/scheme.d.ts

@@ -10,8 +10,8 @@ export declare const CloneRepoQueryLocalSchema: import("zod").ZodObject<{
     reasoning: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>;
 export declare const BulkCloneRepoLocalSchema: import("zod").ZodObject<{
-    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNumber>>;
-    responseCharLength: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNumber>>;
+    responseCharOffset: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
+    responseCharLength: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
     queries: import("zod").ZodArray<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>;
 }, import("zod/v4/core").$strip>;
 export declare const GitHubCloneRepoOutputLocalSchema: import("zod").ZodObject<{
@@ -21,24 +21,71 @@ export declare const GitHubCloneRepoOutputLocalSchema: import("zod").ZodObject<{
     }>>;
     data: import("zod").ZodOptional<import("zod").ZodObject<{
         localPath: import("zod").ZodString;
-        branch: import("zod").ZodString;
-        cached: import("zod").ZodBoolean;
+        resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
         sparsePath: import("zod").ZodOptional<import("zod").ZodString>;
         cloneTimeMs: import("zod").ZodOptional<import("zod").ZodNumber>;
         totalSize: import("zod").ZodOptional<import("zod").ZodNumber>;
         fileCount: import("zod").ZodOptional<import("zod").ZodNumber>;
+        location: import("zod").ZodOptional<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<{
+                file: "file";
+                directory: "directory";
+                repo: "repo";
+                tree: "tree";
+                "archive-entry": "archive-entry";
+            }>;
+            localPath: import("zod").ZodString;
+            repoRoot: import("zod").ZodOptional<import("zod").ZodString>;
+            requestedPath: import("zod").ZodOptional<import("zod").ZodString>;
+            source: import("zod").ZodOptional<import("zod").ZodEnum<{
+                extract: "extract";
+                decompress: "decompress";
+                strings: "strings";
+                unpack: "unpack";
+                tree: "tree";
+                clone: "clone";
+            }>>;
+            cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            complete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>>;
     localPath: import("zod").ZodOptional<import("zod").ZodString>;
-    branch: import("zod").ZodOptional<import("zod").ZodString>;
+    resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
     cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    sparsePath: import("zod").ZodOptional<import("zod").ZodString>;
+    location: import("zod").ZodOptional<import("zod").ZodObject<{
+        kind: import("zod").ZodEnum<{
+            file: "file";
+            directory: "directory";
+            repo: "repo";
+            tree: "tree";
+            "archive-entry": "archive-entry";
+        }>;
+        localPath: import("zod").ZodString;
+        repoRoot: import("zod").ZodOptional<import("zod").ZodString>;
+        requestedPath: import("zod").ZodOptional<import("zod").ZodString>;
+        source: import("zod").ZodOptional<import("zod").ZodEnum<{
+            extract: "extract";
+            decompress: "decompress";
+            strings: "strings";
+            unpack: "unpack";
+            tree: "tree";
+            clone: "clone";
+        }>>;
+        cached: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        complete: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        resolvedBranch: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
     warnings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
         kind: import("zod").ZodString;
     }, import("zod/v4/core").$loose>]>>>;
     error: import("zod").ZodOptional<import("zod").ZodString>;
-    readonly hints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    readonly base: import("zod").ZodOptional<import("zod").ZodString>;
-    readonly shared: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
-    readonly responsePagination: import("zod").ZodOptional<import("zod").ZodObject<{
+    hints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    base: import("zod").ZodOptional<import("zod").ZodString>;
+    shared: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
+    responsePagination: import("zod").ZodOptional<import("zod").ZodObject<{
         currentPage: import("zod").ZodNumber;
         totalPages: import("zod").ZodNumber;
         hasMore: import("zod").ZodBoolean;

package/dist/tools/github_clone_repo/types.d.ts

@@ -1,4 +1,4 @@
-export type CacheSource = 'clone' | 'directoryFetch';
+export type CacheSource = 'clone' | 'directoryFetch' | 'treeFetch';
 export interface CloneCacheMeta {
     clonedAt: string;
     expiresAt: string;

package/dist/tools/github_fetch_content/scheme.d.ts

@@ -32,8 +32,8 @@ export declare const FileContentQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const FileContentBulkQueryLocalSchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strip>;
 export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
@@ -55,6 +55,8 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
         files: z.ZodOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             content: z.ZodString;
+            localPath: z.ZodOptional<z.ZodString>;
+            repoRoot: z.ZodOptional<z.ZodString>;
             contentView: z.ZodOptional<z.ZodEnum<{
                 none: "none";
                 standard: "standard";
@@ -69,6 +71,8 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
                 currentPage: z.ZodNumber;
                 totalPages: z.ZodNumber;
                 hasMore: z.ZodBoolean;
+                nextPage: z.ZodOptional<z.ZodNumber>;
+                nextMatchPage: z.ZodOptional<z.ZodNumber>;
                 charOffset: z.ZodOptional<z.ZodNumber>;
                 charLength: z.ZodOptional<z.ZodNumber>;
                 totalChars: z.ZodOptional<z.ZodNumber>;
@@ -92,10 +96,12 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
             matchNotFound: z.ZodOptional<z.ZodBoolean>;
             searchedFor: z.ZodOptional<z.ZodString>;
+            cached: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
         directories: z.ZodOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             localPath: z.ZodString;
+            repoRoot: z.ZodOptional<z.ZodString>;
             fileCount: z.ZodNumber;
             totalSize: z.ZodNumber;
             files: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -107,14 +113,12 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             resolvedBranch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         owner: z.ZodOptional<z.ZodString>;
         repo: z.ZodOptional<z.ZodString>;
         path: z.ZodOptional<z.ZodString>;
         error: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GitHubFetchContentOutputLocal = z.infer<typeof GitHubFetchContentOutputLocalSchema>;

package/dist/tools/github_fetch_content/types.d.ts

@@ -49,6 +49,7 @@ export interface GitHubFileContentApiResult extends GitHubFileContentApiResultBa
 }
 export interface DirectoryFetchResult {
     localPath: string;
+    repoRoot: string;
     files: Array<{
         path: string;
         size: number;
@@ -63,4 +64,15 @@ export interface DirectoryFetchResult {
     branch: string;
     directoryPath: string;
 }
+export interface FileMaterializationResult {
+    localPath: string;
+    repoRoot: string;
+    path: string;
+    size: number;
+    cached: boolean;
+    expiresAt: string;
+    owner: string;
+    repo: string;
+    branch: string;
+}
 export {};

package/dist/tools/github_search_code/scheme.d.ts

@@ -20,8 +20,8 @@ export declare const GitHubCodeSearchQueryLocalSchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const GitHubCodeSearchBulkQueryLocalSchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strip>;
 export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
@@ -40,7 +40,6 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
         id: z.ZodString;
         data: z.ZodObject<{
             files: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
                 owner: z.ZodString;
                 repo: z.ZodString;
                 path: z.ZodString;
@@ -51,6 +50,7 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
                     matchIndices: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         start: z.ZodNumber;
                         end: z.ZodNumber;
+                        lineOffset: z.ZodNumber;
                     }, z.core.$strip>>>;
                     url: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
@@ -69,20 +69,20 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
                 }>>;
                 totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
                 hasMore: z.ZodBoolean;
+                nextPage: z.ZodOptional<z.ZodNumber>;
                 uniqueFileCount: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     emptyQueries: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
         nonExistentScope: z.ZodOptional<z.ZodLiteral<true>>;
+        incompleteResults: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         error: z.ZodString;
-        hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GitHubCodeSearchOutputLocal = z.infer<typeof GitHubCodeSearchOutputLocalSchema>;

package/dist/tools/github_search_pull_requests/contentResponse.d.ts

@@ -14,5 +14,4 @@ type QueryLike = {
     matchString?: string;
 };
 export declare function shapePullRequestForContent(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest, shouldMinify?: boolean, showContentMap?: boolean): Record<string, unknown>;
-export declare function buildContentHints(pullRequests: Array<Record<string, unknown>>, request: NormalizedPrContentRequest): string[];
 export {};

package/dist/tools/github_search_pull_requests/execution.d.ts

@@ -1,17 +1,7 @@
 import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import type { z } from 'zod';
 import { GitHubPullRequestSearchQueryLocalSchema } from './scheme.js';
-type GitHubPullRequestSearchQuery = z.infer<typeof GitHubPullRequestSearchQueryLocalSchema>;
-import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
 type GitHubPullRequestSearchInput = z.input<typeof GitHubPullRequestSearchQueryLocalSchema>;
-type PartialPRQuery = WithOptionalMeta<GitHubPullRequestSearchQuery>;
 export declare function searchMultipleGitHubPullRequests(args: ToolExecutionArgs<GitHubPullRequestSearchInput>): Promise<CallToolResult>;
-export declare function buildPRSearchOutput(input: {
-    data: Record<string, unknown>;
-    pullRequests: Array<Record<string, unknown>>;
-    extraHints: string[];
-}, _query: PartialPRQuery): {
-    data: Record<string, unknown>;
-    extraHints: string[];
-};
 export {};