@octocodeai/octocode-tools-core 16.3.0 → 16.6.0

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

@@ -0,0 +1,30 @@
+import type { StoredCredentials, StoreResult, DeleteResult } from './types.js';
+import { invalidateCredentialsCache, _getCacheStats, _resetCredentialsCache } from './credentialCache.js';
+import { OCTOCODE_DIR, CREDENTIALS_FILE, KEY_FILE, encrypt, decrypt, ensureOctocodeDir, readCredentialsStore, writeCredentialsStore } from './credentialEncryption.js';
+import { type RefreshResult, type TokenWithRefreshResult } from './tokenRefresh.js';
+import { resolveToken, type ResolvedToken, resolveTokenWithRefresh, type ResolvedTokenWithRefresh, resolveTokenFull, type FullTokenResolution, type GhCliTokenGetter, resetTokenResolution } from './tokenResolution.js';
+import { getTokenFromEnv, getEnvTokenSource, hasEnvToken, ENV_TOKEN_VARS } from './envTokens.js';
+import { isTokenExpired, isRefreshTokenExpired } from './credentialUtils.js';
+export { getTokenFromEnv, getEnvTokenSource, hasEnvToken, ENV_TOKEN_VARS };
+export declare function storeCredentials(credentials: StoredCredentials): Promise<StoreResult>;
+export interface GetCredentialsOptions {
+    bypassCache?: boolean;
+}
+export declare function getCredentials(hostname?: string, options?: GetCredentialsOptions): Promise<StoredCredentials | null>;
+export declare function getCredentialsSync(hostname?: string): StoredCredentials | null;
+export declare function deleteCredentials(hostname?: string): Promise<DeleteResult>;
+export declare function listStoredHosts(): Promise<string[]>;
+export declare function listStoredHostsSync(): string[];
+export declare function hasCredentials(hostname?: string): Promise<boolean>;
+export declare function hasCredentialsSync(hostname?: string): boolean;
+export declare function updateToken(hostname: string, token: StoredCredentials['token']): Promise<boolean>;
+export declare function getCredentialsFilePath(): string;
+export declare function getToken(hostname?: string): Promise<string | null>;
+export declare function getTokenSync(hostname?: string): string | null;
+export { invalidateCredentialsCache, _getCacheStats, _resetCredentialsCache };
+export { encrypt, decrypt, ensureOctocodeDir, readCredentialsStore, writeCredentialsStore, OCTOCODE_DIR, CREDENTIALS_FILE, KEY_FILE, };
+export declare function refreshAuthToken(hostname?: string, clientId?: string): Promise<RefreshResult>;
+export declare function getTokenWithRefresh(hostname?: string, clientId?: string): Promise<TokenWithRefreshResult>;
+export type { RefreshResult, TokenWithRefreshResult };
+export { resolveToken, resolveTokenWithRefresh, resolveTokenFull, resetTokenResolution, type ResolvedToken, type ResolvedTokenWithRefresh, type FullTokenResolution, type GhCliTokenGetter, };
+export { isTokenExpired, isRefreshTokenExpired };

package/dist/shared/credentials/testing.d.ts

@@ -0,0 +1,2 @@
+export { _getCacheStats, _resetCredentialsCache } from './credentialCache.js';
+export { resetTokenResolution } from './tokenResolution.js';

package/dist/shared/credentials/testing.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);
+function o(e){return e.toLowerCase().replace(/^https?:\/\//,"").replace(/\/$/,"")}function s(e){if(!e.token.expiresAt)return!1;let n=new Date(e.token.expiresAt);if(isNaN(n.getTime()))return!0;let t=new Date;return n.getTime()-t.getTime()<300*1e3}var r=new Map,i=300*1e3;function l(e){let n=o(e),t=r.get(n);return!t||Date.now()-t.cachedAt>=i?!1:t.credentials?!s(t.credentials):!0}function a(){let e=Date.now();return{size:r.size,entries:Array.from(r.entries()).map(([n,t])=>({hostname:n,age:e-t.cachedAt,valid:l(n)}))}}function u(){r.clear()}import{execFile as g}from"child_process";var c=null;function f(){c=null}export{a as _getCacheStats,u as _resetCredentialsCache,f as resetTokenResolution};

package/dist/shared/credentials/tokenRefresh.d.ts

@@ -0,0 +1,24 @@
+import type { OAuthToken, StoredCredentials } from './types.js';
+export interface RefreshResult {
+    success: boolean;
+    username?: string;
+    hostname?: string;
+    error?: string;
+}
+type GetCredentialsFn = (hostname?: string) => Promise<StoredCredentials | null>;
+type UpdateTokenFn = (hostname: string, token: OAuthToken) => Promise<boolean>;
+export declare function refreshAuthToken(deps: {
+    getCredentials: GetCredentialsFn;
+    updateToken: UpdateTokenFn;
+}, hostname?: string, clientId?: string): Promise<RefreshResult>;
+export interface TokenWithRefreshResult {
+    token: string | null;
+    source: 'stored' | 'refreshed' | 'none';
+    username?: string;
+    refreshError?: string;
+}
+export declare function getTokenWithRefresh(deps: {
+    getCredentials: GetCredentialsFn;
+    updateToken: UpdateTokenFn;
+}, hostname?: string, clientId?: string): Promise<TokenWithRefreshResult>;
+export {};

package/dist/shared/credentials/tokenResolution.d.ts

@@ -0,0 +1,30 @@
+import type { TokenSource } from './types.js';
+import type { TokenWithRefreshResult } from './tokenRefresh.js';
+interface StorageDeps {
+    getTokenWithRefresh: (hostname?: string, clientId?: string) => Promise<TokenWithRefreshResult>;
+}
+export declare function initTokenResolution(deps: StorageDeps): void;
+export declare function resetTokenResolution(): void;
+export interface FullTokenResolution {
+    token: string;
+    source: TokenSource | 'gh-cli';
+    wasRefreshed?: boolean;
+    username?: string;
+}
+export type GhCliTokenGetter = (hostname?: string) => string | null | Promise<string | null>;
+export declare function resolveTokenFull(options?: {
+    hostname?: string;
+    clientId?: string;
+    getGhCliToken?: GhCliTokenGetter;
+}): Promise<FullTokenResolution | null>;
+export interface ResolvedToken {
+    token: string;
+    source: TokenSource;
+}
+export declare function resolveToken(hostname?: string): Promise<ResolvedToken | null>;
+export interface ResolvedTokenWithRefresh extends ResolvedToken {
+    wasRefreshed?: boolean;
+    username?: string;
+}
+export declare function resolveTokenWithRefresh(hostname?: string, clientId?: string): Promise<ResolvedTokenWithRefresh | null>;
+export {};

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

@@ -0,0 +1,28 @@
+export interface OAuthToken {
+    token: string;
+    tokenType: 'oauth';
+    scopes?: string[];
+    refreshToken?: string;
+    expiresAt?: string;
+    refreshTokenExpiresAt?: string;
+}
+export interface StoredCredentials {
+    hostname: string;
+    username: string;
+    token: OAuthToken;
+    gitProtocol: 'ssh' | 'https';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface StoreResult {
+    success: boolean;
+}
+export interface DeleteResult {
+    success: boolean;
+    deletedFromFile: boolean;
+}
+export interface CredentialsStore {
+    version: number;
+    credentials: Record<string, StoredCredentials>;
+}
+export type TokenSource = 'env:OCTOCODE_TOKEN' | 'env:GH_TOKEN' | 'env:GITHUB_TOKEN' | 'octocode-storage' | 'gh-cli' | null;

package/dist/shared/fs-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getDirectorySizeBytes(targetPath: string): number;
+export declare function formatBytes(bytes: number): string;

package/dist/shared/fs-utils.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 f,readdirSync as u,lstatSync as l}from"node:fs";import{join as m}from"node:path";function a(n){if(!f(n))return 0;let r=0,t=[n];for(;t.length>0;){let e=t.pop(),o;try{o=u(e)}catch{continue}for(let s of o){let c=m(e,s);try{let i=l(c);if(i.isSymbolicLink())continue;i.isDirectory()?t.push(c):i.isFile()&&(r+=i.size)}catch{}}}return r}function d(n){if(n<1024)return`${n} B`;let r=n/1024;if(r<1024)return`${r.toFixed(1)} KB`;let t=r/1024;return t<1024?`${t.toFixed(1)} MB`:`${(t/1024).toFixed(2)} GB`}export{d as formatBytes,a as getDirectorySizeBytes};

package/dist/shared/index.d.ts

@@ -0,0 +1,6 @@
+export * from './credentials/index.js';
+export * from './platform/index.js';
+export * from './session/index.js';
+export * from './config/index.js';
+export * from './paths.js';
+export * from './fs-utils.js';

package/dist/shared/languageSelectors.d.ts

@@ -0,0 +1,23 @@
+export type OqlLanguageSelectorKind = 'extension' | 'language' | 'unknown';
+export type OqlLanguageSelector = {
+    raw: string;
+    normalized: string;
+    kind: OqlLanguageSelectorKind;
+    canonicalLanguage?: string;
+    extension?: string;
+    extensions?: readonly string[];
+};
+export declare function classifyLanguageSelector(raw: string | undefined): OqlLanguageSelector | undefined;
+export type GithubCodeLanguageParams = {
+    language?: string;
+    extension?: string;
+};
+export type LocalSearchLanguageParams = {
+    langType?: string;
+    include?: string[];
+};
+export declare function toGithubCodeLanguageParams(raw: string | undefined): GithubCodeLanguageParams;
+export declare function toLocalSearchLanguageParams(raw: string | undefined): LocalSearchLanguageParams;
+export declare function toLocalFileLanguageGlobs(raw: string | undefined): string[];
+export declare function toStructuralSearchIncludeGlobs(raw: string | undefined): string[] | undefined;
+export declare function toGithubRepositoryLanguage(raw: string | undefined): string | undefined;

package/dist/shared/paths.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 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 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 n,mkdirSync as i}from"node:fs";import{join as e}from"node:path";import p from"node:os";import g from"node:path";var c=p.platform()==="win32",f=p.platform()==="darwin",x=p.platform()==="linux",r=p.homedir();function m(){return c?process.env.APPDATA||g.join(r,"AppData","Roaming"):r}var d=".octocode",s=448;function v(l){let a=process.env[l];return a&&a.trim().length>0?a:void 0}function A(){return c?e(m(),d):f?e(r,d):e(v("XDG_CONFIG_HOME")??e(r,".config"),d)}var t=A(),o={home:t,config:e(t,".octocoderc"),credentials:e(t,"credentials.json"),key:e(t,".key"),session:e(t,"session.json"),stats:e(t,"stats.json"),tmp:e(t,"tmp"),clone:e(t,"tmp","clone"),tree:e(t,"tmp","tree"),binary:e(t,"tmp","binary"),repos:e(t,"tmp","clone"),unzip:e(t,"tmp","unzip"),cliConfig:e(t,"config.json"),lspConfig:e(t,"lsp-servers.json")};function h(){n(o.home)||i(o.home,{recursive:!0,mode:s})}function z(){D()}function u(){h(),n(o.tmp)||i(o.tmp,{recursive:!0,mode:s})}function D(){u(),n(o.clone)||i(o.clone,{recursive:!0,mode:s})}function N(){u(),n(o.tree)||i(o.tree,{recursive:!0,mode:s})}function T(){u(),n(o.binary)||i(o.binary,{recursive:!0,mode:s})}function _(){u(),n(o.unzip)||i(o.unzip,{recursive:!0,mode:s})}export{t as OCTOCODE_HOME,T as ensureBinary,D as ensureClone,h as ensureHome,z as ensureRepos,u as ensureTmp,N as ensureTree,_ as ensureUnzip,A as getDefaultOctocodeHome,o 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,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{randomUUID as pt}from"node:crypto";import{existsSync as J,readFileSync as ye,writeFileSync as st,unlinkSync as nt,renameSync as ot}from"node:fs";function h(e){return e.toLowerCase().replace(/^https?:\/\//,"").replace(/\/$/,"")}function P(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 z(e){if(!e.token.refreshTokenExpiresAt)return!1;let t=new Date(e.token.refreshTokenExpiresAt);return isNaN(t.getTime())?!0:new Date>=t}var E=new Map,Ae=300*1e3;function we(e){let t=h(e),r=E.get(t);return!r||Date.now()-r.cachedAt>=Ae?!1:r.credentials?!P(r.credentials):!0}function ee(e){e?E.delete(h(e)):E.clear()}function te(e){let t=h(e);if(we(t))return E.get(t).credentials}function re(e,t){let r=h(e);E.set(r,{credentials:t,cachedAt:Date.now()})}import{existsSync as oe,readFileSync as ie,writeFileSync as ae,unlinkSync as Xt,statSync as je,chmodSync as Ue}from"node:fs";import{createCipheriv as Me,createDecipheriv as Be,randomBytes as ce}from"node:crypto";import{existsSync as He,mkdirSync as De}from"node:fs";import{join as c}from"node:path";import _ from"node:os";import Oe from"node:path";var I=_.platform()==="win32",W=_.platform()==="darwin",Le=_.platform()==="linux",T=_.homedir();function K(){return I?process.env.APPDATA||Oe.join(T,"AppData","Roaming"):T}var V=".octocode",Fe=448;function _e(e){let t=process.env[e];return t&&t.trim().length>0?t:void 0}function Ie(){return I?c(K(),V):W?c(T,V):c(_e("XDG_CONFIG_HOME")??c(T,".config"),V)}var u=Ie(),f={home:u,config:c(u,".octocoderc"),credentials:c(u,"credentials.json"),key:c(u,".key"),session:c(u,"session.json"),stats:c(u,"stats.json"),tmp:c(u,"tmp"),clone:c(u,"tmp","clone"),tree:c(u,"tmp","tree"),binary:c(u,"tmp","binary"),repos:c(u,"tmp","clone"),unzip:c(u,"tmp","unzip"),cliConfig:c(u,"config.json"),lspConfig:c(u,"lsp-servers.json")};function se(){He(f.home)||De(f.home,{recursive:!0,mode:Fe})}import{z as a}from"zod";var Ne=a.object({token:a.string(),tokenType:a.literal("oauth"),scopes:a.array(a.string()).optional(),refreshToken:a.string().optional(),expiresAt:a.string().optional(),refreshTokenExpiresAt:a.string().optional()}),Ge=a.object({hostname:a.string(),username:a.string(),token:Ne,gitProtocol:a.enum(["ssh","https"]),createdAt:a.string(),updatedAt:a.string()}),ne=a.object({version:a.number(),credentials:a.record(a.string(),Ge)});var ze=f.home,N=f.credentials,k=f.key,ue="aes-256-gcm",We=16;function x(){se()}function le(){if(x(),oe(k))return je(k).mode&511&63&&Ue(k,384),Buffer.from(ie(k,"utf8"),"hex");let e=ce(32);return ae(k,e.toString("hex"),{mode:384}),e}function fe(e){let t=le(),r=ce(We),s=Me(ue,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 pe(e){let t=le(),[r,s,n]=e.split(":");if(!r||!s||!n)throw new Error("Invalid encrypted data format");let i=Buffer.from(r,"hex"),C=Buffer.from(s,"hex"),m=Be(ue,t,i);m.setAuthTag(C);let Q=m.update(n,"hex","utf8");return Q+=m.final("utf8"),Q}function $(){if(x(),!oe(N))return{version:1,credentials:{}};try{let e=ie(N,"utf8"),t=pe(e),r=JSON.parse(t),s=ne.safeParse(r);return s.success?s.data:{version:1,credentials:{}}}catch{return{version:1,credentials:{}}}}function de(e){x();let t=fe(JSON.stringify(e,null,2));ae(N,t,{mode:384})}import{refreshToken as Ke}from"@octokit/oauth-methods";import{request as Ve}from"@octokit/request";var G="178c6fc778ccc68e1d6a",A="github.com";function $e(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 Je(e){return e==="github.com"||e===A?"https://api.github.com":`https://${e}/api/v3`}async function me(e,t=A,r=G){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(z(s))return{success:!1,error:"Refresh token has expired. Please login again."};try{let n=await Ke({clientType:"github-app",clientId:r,clientSecret:"",refreshToken:s.token.refreshToken,request:Ve.defaults({baseUrl:Je(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?$e(n.message):"Token refresh failed"}}}async function he(e,t=A,r=G){let s=await e.getCredentials(t);if(!s||!s.token)return{token:null,source:"none"};if(!P(s))return{token:s.token.token,source:"stored",username:s.username};if(s.token.refreshToken){let n=await me(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 fr}from"child_process";var qe=null;function Se(e){qe=e}async function Ye(e){let t=h(e.hostname),r={...e,hostname:t,updatedAt:new Date().toISOString()};try{let s=$();return s.credentials[t]=r,de(s),ee(t),{success:!0}}catch{throw new Error("Failed to store credentials")}}async function ge(e="github.com",t){let r=h(e);if(!t?.bypassCache){let i=te(r);if(i!==void 0)return i}let n=$().credentials[r]||null;return re(r,n),n}async function Ze(e,t){let r=await ge(e);return r?(r.token=t,r.updatedAt=new Date().toISOString(),await Ye(r),!0):!1}async function Xe(e,t){return he({getCredentials:ge,updateToken:Ze},e,t)}Se({getTokenWithRefresh:Xe});import{z as o}from"zod";var Qe=o.object({rawChars:o.number(),responseChars:o.number(),savedChars:o.number(),calls:o.number()}),et=o.object({hits:o.record(o.string(),o.number()).default({}),rateLimits:o.number().default(0)}),j=o.record(o.string(),o.number()).default({}),tt=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(),Qe).default({}),githubCacheHits:et.default({hits:{},rateLimits:0}),packageRegistryFailures:j,totalUsage:tt.optional()}),Ce=o.object({version:o.literal(1),sessionId:o.string(),createdAt:o.string(),lastActiveAt:o.string(),stats:U.optional()}),Te=o.object({version:o.literal(1),stats:U});function ke(e){return Object.values(e).reduce((t,r)=>t+r,0)}function rt(e){let t=e.charsSavedByTool??{},r=e.githubCacheHits??{hits:{},rateLimits:0},s=e.rateLimitsByProvider??{},n=e.packageRegistryFailures??{},i=Object.values(t).reduce((C,m)=>({rawChars:C.rawChars+m.rawChars,responseChars:C.responseChars+m.responseChars,savedChars:C.savedChars+m.savedChars,charSavingsCalls:C.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:ke(r.hits),githubCacheRateLimits:r.rateLimits,packageRegistryFailures:ke(n),packageRegistryFailuresByRegistry:n}}function p(e){let t={...e,rateLimitsByProvider:e.rateLimitsByProvider??{},charsSavedByTool:e.charsSavedByTool??{},githubCacheHits:e.githubCacheHits??{hits:{},rateLimits:0},packageRegistryFailures:e.packageRegistryFailures??{}};return{...t,totalUsage:rt(t)}}function w(){return p({toolCalls:0,errors:0,rateLimits:0,rateLimitsByProvider:{},charsSavedByTool:{},githubCacheHits:{hits:{},rateLimits:0},packageRegistryFailures:{}})}var y=f.session,v=f.stats;function xe(e,t){let r=`${e}.tmp`;st(r,JSON.stringify(t,null,2),{mode:384}),ot(r,e)}function it(e){let{stats:t,...r}=e;return r}function at(e){let t=JSON.parse(e),r=Te.safeParse(t);if(r.success)return p(r.data.stats);let s=U.safeParse(t);return s.success?p(s.data):null}function ct(e){let t=e?p(e):w();if(!J(v))return t;try{let r=ye(v,"utf8"),s=at(r);return s||t}catch{return t}}function M(e){x(),xe(v,{version:e.version,stats:p(e.stats)}),xe(y,it(e))}function ve(){if(!J(y))return null;try{let e=ye(y,"utf8"),t=JSON.parse(e),r=Ce.safeParse(t);return r.success?{...r.data,stats:ct(r.data.stats)}:null}catch{return null}}function Re(){let e=!1;for(let t of[y,v])if(J(t))try{nt(t),e=!0}catch{return!1}return e}var ut=6e4,l=null,S=!1,R=null,q=!1,O=null,L=null,H=null,B=!1;function lt(){q||(q=!0,O=()=>{D()},L=()=>{D()},H=()=>{D()},process.on("exit",O),process.on("SIGINT",L),process.on("SIGTERM",H))}function Y(){O&&(process.removeListener("exit",O),O=null),L&&(process.removeListener("SIGINT",L),L=null),H&&(process.removeListener("SIGTERM",H),H=null),q=!1}function ft(){R||(R=setInterval(()=>{S&&l&&(M(l),S=!1)},ut),R.unref())}function Z(){R&&(clearInterval(R),R=null)}function b(){if(l)return l;let e=ve();return e&&(l=e),e}function g(e){l=e,S=!0,lt(),ft()}function F(){S&&l&&(M(l),S=!1)}function D(){if(!B&&S&&l){B=!0;try{M(l),S=!1}catch{}finally{B=!1}}}function X(){l=null,S=!1,B=!1}function be(){X(),Z(),Y()}var dt=1;function mt(e){return p(e)}function ht(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 Pe(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 St(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 Ee(){let e=new Date().toISOString();return{version:dt,sessionId:pt(),createdAt:e,lastActiveAt:e,stats:w()}}function gt(){return b()}function Ct(e){g(e)}function Tt(){F()}function kt(){D()}function xt(e){if(e?.forceNew){let s=Ee();return g(s),F(),s}let t=b();if(t){let s={...t,lastActiveAt:new Date().toISOString()};return g(s),F(),s}let r=Ee();return g(r),F(),r}function yt(){return b()?.sessionId??null}function d(e){let t=b();if(!t)return{success:!1,session:null};let r=mt(t.stats),s=p({toolCalls:r.toolCalls+(e.toolCalls??0),errors:r.errors+(e.errors??0),rateLimits:r.rateLimits+(e.rateLimits??0),rateLimitsByProvider:Pe(r.rateLimitsByProvider,e.rateLimitsByProvider),charsSavedByTool:ht(r.charsSavedByTool,e.charsSavedByTool),githubCacheHits:St(r.githubCacheHits,e.githubCacheHits),packageRegistryFailures:Pe(r.packageRegistryFailures,e.packageRegistryFailures)}),n={...t,lastActiveAt:new Date().toISOString(),stats:s};return g(n),{success:!0,session:n}}function vt(e=1){return d({toolCalls:e})}function Rt(e=1){return d({errors:e})}function bt(e=1){return d({rateLimits:e})}function Pt(e,t=1){return d({rateLimits:t,rateLimitsByProvider:{[e]:t}})}function Et(e,t,r){let s=Number.isFinite(t)?Math.max(0,t):0,n=Number.isFinite(r)?Math.max(0,r):0;return d({charsSavedByTool:{[e]:{rawChars:s,responseChars:n,savedChars:Math.max(0,s-n),calls:1}}})}function At(e,t=1){return d({githubCacheHits:{hits:{[e]:t},rateLimits:0}})}function wt(e=1){return d({githubCacheHits:{hits:{},rateLimits:e}})}function Ot(e,t=1){return d({packageRegistryFailures:{[e]:t}})}function Lt(){let e=b();if(!e)return{success:!1,session:null};let t={...e,lastActiveAt:new Date().toISOString(),stats:w()};return g(t),{success:!0,session:t}}function Ht(){return X(),Z(),Y(),Re()}function Dt(){be()}export{y as SESSION_FILE,v as STATS_FILE,Dt as _resetSessionState,Ht as deleteSession,Tt as flushSession,kt as flushSessionSync,xt as getOrCreateSession,yt as getSessionId,Rt as incrementErrors,At as incrementGitHubCacheHits,wt as incrementGitHubCacheRateLimits,Ot as incrementPackageRegistryFailures,Pt as incrementRateLimitByProvider,bt as incrementRateLimits,vt as incrementToolCalls,Et as incrementToolCharSavings,gt as readSession,Lt as resetSessionStats,d as updateSessionStats,Ct 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/directToolCatalog.d.ts

@@ -1,56 +1,15 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-export type DirectToolInput = Record<string, unknown> & {
-    queries: unknown[];
-};
-export interface DirectToolDefinition {
-    name: string;
-    schema: z.ZodType;
-    inputSchema: z.ZodType;
-}
-export type DirectToolCategory = 'GitHub' | 'Local' | 'LSP' | 'Package' | 'Other';
-export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
-export interface DirectToolDisplayField {
-    name: string;
-    required: boolean;
-    type: string;
-    /** Numeric bounds and default, e.g. "1-100, default 30" — surfaced inline so
-     * agents see the full constraint without fetching the raw JSON schema. */
-    constraints?: string;
-    description?: string;
-}
-export interface DirectToolOutputField {
-    name: string;
-    type: string;
-    optional?: boolean;
-}
-export interface DirectToolMetadata {
-    tools?: Record<string, {
-        description?: string;
-        schema?: Record<string, string>;
-    }>;
-}
-export interface PrepareDirectToolInputOptions {
-    sourceLabel?: string;
-    onUnknownFields?: (unknownFields: string[], queryIndex: number) => void;
-}
-export declare class DirectToolInputError extends Error {
-    readonly details: string[];
-    constructor(message: string, details?: string[]);
-}
-export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
-export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
-export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
-export declare function sortDirectToolNames(toolNames: string[]): string[];
-export declare function formatDirectToolSchemaText(toolName: string): string;
-export declare function formatDirectToolMetadataSchemaText(schema: Record<string, string> | undefined): string;
-export declare function getDirectToolAutoFilledFields(toolName: string): string[];
-export declare function getDirectToolOutputFields(): DirectToolOutputField[];
-export declare function formatDirectToolOutputSchemaText(): string;
-export declare function getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;
-export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
-export declare function buildDirectToolExampleQuery(toolName: string): Record<string, unknown>;
-export declare function prepareDirectToolInputFromJsonText(toolName: string, inputText: string | undefined, options?: PrepareDirectToolInputOptions): DirectToolInput | null;
-export declare function prepareDirectToolInput(toolName: string, rawPayload: unknown, options?: PrepareDirectToolInputOptions): DirectToolInput;
-export declare function formatDirectToolValidationIssues(error: z.ZodError): string[];
-export declare function executeDirectTool(name: string, input: unknown): Promise<CallToolResult>;
+/**
+ * Direct-tool catalog barrel (P3). The catalog is split so the schema/help path
+ * never loads the native engine:
+ *   - `directToolCatalog.meta.ts` — engine-free definitions, schema text,
+ *     display fields, input preparation (also exposed via the `/schema` subpath).
+ *   - `directToolCatalog.exec.ts` — `executeDirectTool` + the engine/runtime.
+ *
+ * This barrel preserves the historical `@octocodeai/octocode-tools-core/direct`
+ * surface (meta + executeDirectTool). Importing it still eagerly loads the engine
+ * (via the exec module) — execution consumers want that. Pure schema/help/
+ * `--scheme`/`context` callers must import from `/schema` (meta only) instead, so
+ * they run on engine-less runtimes.
+ */
+export * from './directToolCatalog.meta.js';
+export { executeDirectTool } from './directToolCatalog.exec.js';

package/dist/tools/directToolCatalog.exec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Direct-tool EXECUTION path (P3). This module imports the engine (native LSP
+ * client pool) and every tool's execution function via `ALL_TOOLS`, so it is the
+ * one that loads the native `.node` addon at eval. It is reached only when a tool
+ * actually runs — schema/help/`--scheme`/`context` use `directToolCatalog.meta.ts`
+ * (and the `@octocodeai/octocode-tools-core/schema` subpath), which is engine-free.
+ */
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { DirectToolInputError } from './directToolCatalog.meta.js';
+export declare function executeDirectTool(name: string, input: unknown): Promise<CallToolResult>;
+export { DirectToolInputError };