klyro 0.1.1

package/dist/tools/registry.js

@@ -0,0 +1,87 @@
+/**
+ * Tool registry — single source of truth for tools the model can use.
+ */
+import { readFileTool } from './fs/read-file.js';
+import { writeFileTool } from './fs/write-file.js';
+import { editFileTool } from './fs/edit-file.js';
+import { listDirTool } from './fs/list-dir.js';
+import { globTool } from './search/glob.js';
+import { grepTool } from './search/grep.js';
+import { searchFilesTool } from './search/search-files.js';
+import { recentFilesTool } from './search/recent-files.js';
+import { dependenciesTool } from './search/dependencies.js';
+import { shellExecTool } from './shell/shell-exec.js';
+import { gitStatusTool } from './git/git-status.js';
+import { gitDiffTool } from './git/git-diff.js';
+import { runVerifyTool } from './verify/run-verify.js';
+import { zodToJsonSchema } from './schema.js';
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        if (this.tools.has(tool.name)) {
+            throw new Error(`Tool already registered: ${tool.name}`);
+        }
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    list() {
+        return [...this.tools.values()];
+    }
+    /** Tools in OpenAI-style tool definition format. */
+    toOpenAITools() {
+        return this.list().map((t) => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: zodToJsonSchema(t.inputSchema),
+            },
+        }));
+    }
+    /** Cached JSON Schemas keyed by tool name (for adapter consumers). */
+    jsonSchemas() {
+        const out = {};
+        for (const t of this.list()) {
+            out[t.name] = zodToJsonSchema(t.inputSchema);
+        }
+        return out;
+    }
+    async execute(name, rawInput, ctx) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return { ok: false, error: { code: 'UNKNOWN_TOOL', message: `Unknown tool: ${name}` } };
+        }
+        const parsed = tool.inputSchema.safeParse(rawInput);
+        if (!parsed.success) {
+            return {
+                ok: false,
+                error: {
+                    code: 'INVALID_INPUT',
+                    message: `Invalid input for ${name}`,
+                    details: parsed.error.issues,
+                },
+            };
+        }
+        return tool.execute(parsed.data, ctx);
+    }
+}
+export const builtinRegistry = () => {
+    const r = new ToolRegistry();
+    r.register(readFileTool);
+    r.register(writeFileTool);
+    r.register(editFileTool);
+    r.register(listDirTool);
+    r.register(globTool);
+    r.register(grepTool);
+    r.register(searchFilesTool);
+    r.register(recentFilesTool);
+    r.register(dependenciesTool);
+    r.register(shellExecTool);
+    r.register(gitStatusTool);
+    r.register(gitDiffTool);
+    r.register(runVerifyTool);
+    return r;
+};

package/dist/tools/schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * JSON Schema derivation from Zod 4 schemas.
+ *
+ * Zod 4 stores constraints on the schema object itself (e.g. `s.minLength`),
+ * not in `_zod.def`. We read them directly. For Zod 3 the constraints live
+ * in `_def`, so this module falls back to that.
+ *
+ * Supports: string, number, integer, boolean, enum, literal, array, object,
+ * optional, nullable, default, union, description, min/max length, min/max.
+ */
+import type { z } from 'zod';
+export interface JsonSchema {
+    type?: string;
+    description?: string;
+    enum?: unknown[];
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    additionalProperties?: boolean | JsonSchema;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    anyOf?: JsonSchema[];
+    format?: string;
+}
+export declare function zodToJsonSchema(schema: z.ZodType<unknown>): JsonSchema;

package/dist/tools/schema.js

@@ -0,0 +1,183 @@
+/**
+ * JSON Schema derivation from Zod 4 schemas.
+ *
+ * Zod 4 stores constraints on the schema object itself (e.g. `s.minLength`),
+ * not in `_zod.def`. We read them directly. For Zod 3 the constraints live
+ * in `_def`, so this module falls back to that.
+ *
+ * Supports: string, number, integer, boolean, enum, literal, array, object,
+ * optional, nullable, default, union, description, min/max length, min/max.
+ */
+function getType(s) {
+    const zod4 = s._zod?.def?.type;
+    if (zod4)
+        return zod4;
+    return s._def?.typeName;
+}
+function getDesc(s) {
+    return s.description ?? s._zod?.def?.description ?? s._def?.description;
+}
+export function zodToJsonSchema(schema) {
+    return convert(schema, new Set());
+}
+function convert(schema, seen) {
+    if (!schema || typeof schema !== 'object')
+        return { type: 'object' };
+    if (seen.has(schema))
+        return { type: 'object' };
+    seen.add(schema);
+    const typeName = getType(schema);
+    const desc = getDesc(schema);
+    const result = {};
+    if (desc)
+        result.description = desc;
+    switch (typeName) {
+        case 'ZodString':
+        case 'string': {
+            result.type = 'string';
+            if (typeof schema.minLength === 'number')
+                result.minLength = schema.minLength;
+            if (typeof schema.maxLength === 'number')
+                result.maxLength = schema.maxLength;
+            if (schema.pattern) {
+                result.pattern = typeof schema.pattern === 'string' ? schema.pattern : schema.pattern.source ?? undefined;
+            }
+            break;
+        }
+        case 'ZodNumber':
+        case 'number': {
+            result.type = schema.isInt === true ? 'integer' : 'number';
+            if (typeof schema.minValue === 'number')
+                result.minimum = schema.minValue;
+            if (typeof schema.maxValue === 'number')
+                result.maximum = schema.maxValue;
+            break;
+        }
+        case 'ZodBigInt':
+        case 'bigint':
+            result.type = 'integer';
+            break;
+        case 'ZodBoolean':
+        case 'boolean':
+            result.type = 'boolean';
+            break;
+        case 'ZodNull':
+        case 'null':
+            result.type = 'null';
+            break;
+        case 'ZodDate':
+        case 'date':
+            result.type = 'string';
+            result.format = 'date-time';
+            break;
+        case 'ZodArray':
+        case 'array':
+            result.type = 'array';
+            if (schema.element)
+                result.items = convert(schema.element, seen);
+            break;
+        case 'ZodObject':
+        case 'object': {
+            result.type = 'object';
+            const shape = schema.shape ?? {};
+            const props = {};
+            const required = [];
+            for (const [key, value] of Object.entries(shape)) {
+                const child = convert(value, seen);
+                props[key] = child;
+                const childType = getType(value);
+                if (childType !== 'ZodOptional' && childType !== 'ZodDefault' && childType !== 'optional' && childType !== 'default') {
+                    required.push(key);
+                }
+            }
+            result.properties = props;
+            if (required.length > 0)
+                result.required = required;
+            result.additionalProperties = false;
+            break;
+        }
+        case 'ZodEnum':
+        case 'enum': {
+            const entries = schema.entries ??
+                schema.values ??
+                schema._zod?.def?.entries ??
+                {};
+            const values = Object.values(entries);
+            if (values.length > 0) {
+                result.type = typeof values[0] === 'number' ? 'number' : 'string';
+                result.enum = values;
+            }
+            else {
+                result.type = 'string';
+            }
+            break;
+        }
+        case 'ZodLiteral':
+        case 'literal': {
+            const v = schema.value;
+            if (typeof v === 'string')
+                result.type = 'string';
+            else if (typeof v === 'number')
+                result.type = 'number';
+            else if (typeof v === 'boolean')
+                result.type = 'boolean';
+            else if (v === null)
+                result.type = 'null';
+            result.enum = [v];
+            break;
+        }
+        case 'ZodUnion':
+        case 'union':
+        case 'ZodDiscriminatedUnion':
+        case 'discriminated_union': {
+            const options = schema.options ?? [];
+            result.anyOf = options.map((o) => convert(o, seen));
+            break;
+        }
+        case 'ZodOptional':
+        case 'optional':
+        case 'ZodNullable':
+        case 'nullable': {
+            const inner = schema.innerType ?? schema._zod?.def?.innerType;
+            if (inner)
+                return convert(inner, seen);
+            break;
+        }
+        case 'ZodDefault':
+        case 'default': {
+            const inner = schema.innerType ?? schema._zod?.def?.innerType;
+            if (inner) {
+                const innerSchema = convert(inner, seen);
+                // Zod 3: defaultValue is a function. Zod 4: it's a value on _zod.def.
+                const dv = schema.defaultValue ??
+                    schema._zod?.def?.defaultValue;
+                if (typeof dv === 'function') {
+                    try {
+                        innerSchema.default = dv();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+                else if (dv !== undefined) {
+                    innerSchema.default = dv;
+                }
+                return innerSchema;
+            }
+            break;
+        }
+        case 'ZodPipe':
+        case 'pipe':
+        case 'ZodTransform':
+        case 'transform':
+            if (schema.innerType)
+                return convert(schema.innerType, seen);
+            result.type = 'object';
+            result.additionalProperties = true;
+            break;
+        default:
+            result.type = 'object';
+            result.additionalProperties = true;
+    }
+    return result;
+}

package/dist/tools/search/dependencies.d.ts

@@ -0,0 +1,44 @@
+/**
+ * dependencies — surface direct dependencies of the repo.
+ *
+ * Reads package.json / requirements.txt / go.mod / Cargo.toml / pyproject.toml
+ * and returns the first-party name + version list. Does NOT recurse into
+ * transitive deps (that's a "lockfile parse" feature, not Level 6).
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    ecosystem: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        npm: "npm";
+        python: "python";
+        go: "go";
+        rust: "rust";
+    }>>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface Dep {
+    name: string;
+    version?: string;
+    ecosystem: 'npm' | 'python' | 'go' | 'rust';
+}
+export interface DependenciesOutput {
+    ecosystem?: string;
+    dependencies: Dep[];
+    source?: string;
+}
+export declare const dependenciesTool: import("../types.js").Tool<{
+    cwd?: string | undefined;
+    ecosystem?: "auto" | "npm" | "python" | "go" | "rust" | undefined;
+    maxResults?: number | undefined;
+}, {
+    dependencies: never[];
+    ecosystem?: undefined;
+    source?: undefined;
+} | {
+    ecosystem: "npm" | "python" | "go" | "rust" | undefined;
+    source: string;
+    dependencies: Dep[];
+}>;
+export type DependenciesInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/search/dependencies.js

@@ -0,0 +1,188 @@
+/**
+ * dependencies — surface direct dependencies of the repo.
+ *
+ * Reads package.json / requirements.txt / go.mod / Cargo.toml / pyproject.toml
+ * and returns the first-party name + version list. Does NOT recurse into
+ * transitive deps (that's a "lockfile parse" feature, not Level 6).
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    cwd: z.string().optional(),
+    ecosystem: z.enum(['auto', 'npm', 'python', 'go', 'rust']).optional().describe('Force a specific ecosystem; default auto-detect'),
+    maxResults: z.number().int().min(1).max(500).optional().describe('Cap (default 200)'),
+});
+const DEFAULT_MAX = 200;
+const MAX_BYTES = 64 * 1024;
+async function readJson(p) {
+    try {
+        const s = await fs.stat(p);
+        if (!s.isFile() || s.size > MAX_BYTES)
+            return null;
+        return JSON.parse(await fs.readFile(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function readText(p) {
+    try {
+        const s = await fs.stat(p);
+        if (!s.isFile() || s.size > MAX_BYTES)
+            return null;
+        return await fs.readFile(p, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+function parseNpmDeps(pkg) {
+    const out = [];
+    for (const key of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+        const d = pkg[key];
+        if (!d || typeof d !== 'object')
+            continue;
+        const section = d;
+        for (const [name, version] of Object.entries(section)) {
+            if (typeof version === 'string')
+                out.push({ name, version, ecosystem: 'npm' });
+            else
+                out.push({ name, ecosystem: 'npm' });
+        }
+    }
+    return out;
+}
+function parsePythonReq(text) {
+    const out = [];
+    for (const raw of text.split(/\r?\n/)) {
+        const l = raw.trim();
+        if (!l || l.startsWith('#') || l.startsWith('-'))
+            continue;
+        // PEP 508: name [@ url] [version_spec] [; markers]
+        const m = /^([A-Za-z0-9_.\-]+)(?:\s*([@=<>~!]+)\s*([^\s;]+))?/.exec(l);
+        if (!m || !m[1])
+            continue;
+        const name = m[1];
+        const version = m[3];
+        const dep = version ? { name, version, ecosystem: 'python' } : { name, ecosystem: 'python' };
+        out.push(dep);
+    }
+    return out;
+}
+function parseGoMod(text) {
+    const out = [];
+    // require ( ... ) block, or single-line: require foo v1.2.3
+    const block = /\brequire\s+\(([\s\S]*?)\)/g;
+    let m;
+    while ((m = block.exec(text)) !== null) {
+        for (const line of m[1].split(/\r?\n/)) {
+            const t = line.trim();
+            if (!t || t.startsWith('//'))
+                continue;
+            const parts = t.split(/\s+/);
+            if (parts.length >= 2 && parts[0])
+                out.push({ name: parts[0], version: parts[1], ecosystem: 'go' });
+        }
+    }
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        const m2 = /^require\s+([^\s]+)\s+(\S+)/.exec(t);
+        if (m2 && m2[1] && m2[2])
+            out.push({ name: m2[1], version: m2[2], ecosystem: 'go' });
+    }
+    return out;
+}
+function parseCargo(text) {
+    const out = [];
+    let inDeps = false;
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (t === '[dependencies]') {
+            inDeps = true;
+            continue;
+        }
+        if (t.startsWith('[') && t !== '[dependencies]') {
+            inDeps = false;
+            continue;
+        }
+        if (!inDeps)
+            continue;
+        if (!t || t.startsWith('#'))
+            continue;
+        const m = /^([A-Za-z0-9_\-]+)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[\s\S]*?\}))/.exec(t);
+        if (m && m[1]) {
+            const version = m[2] ?? m[3] ?? undefined;
+            out.push({ name: m[1], version, ecosystem: 'rust' });
+        }
+    }
+    return out;
+}
+export const dependenciesTool = defineTool({
+    name: 'dependencies',
+    description: 'List direct dependencies of the repo (npm, Python, Go, or Rust). Use to understand the project\'s surface area without reading every manifest file.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
+            const max = input.maxResults ?? DEFAULT_MAX;
+            const want = input.ecosystem ?? 'auto';
+            const tryNpm = async () => {
+                const pkg = await readJson(path.join(base, 'package.json'));
+                if (!pkg)
+                    return null;
+                return { source: 'package.json', deps: parseNpmDeps(pkg) };
+            };
+            const tryPy = async () => {
+                const t = await readText(path.join(base, 'requirements.txt'));
+                if (t)
+                    return { source: 'requirements.txt', deps: parsePythonReq(t) };
+                const pp = await readText(path.join(base, 'pyproject.toml'));
+                if (pp) {
+                    // minimal: only the [project] dependencies = [...] form
+                    const m = /\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/.exec(pp);
+                    if (m && m[1]) {
+                        const items = m[1].split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+                        return { source: 'pyproject.toml', deps: items.map((name) => ({ name, ecosystem: 'python' })) };
+                    }
+                }
+                return null;
+            };
+            const tryGo = async () => {
+                const t = await readText(path.join(base, 'go.mod'));
+                if (!t)
+                    return null;
+                return { source: 'go.mod', deps: parseGoMod(t) };
+            };
+            const tryCargo = async () => {
+                const t = await readText(path.join(base, 'Cargo.toml'));
+                if (!t)
+                    return null;
+                return { source: 'Cargo.toml', deps: parseCargo(t) };
+            };
+            let picked = null;
+            if (want === 'npm')
+                picked = await tryNpm();
+            else if (want === 'python')
+                picked = await tryPy();
+            else if (want === 'go')
+                picked = await tryGo();
+            else if (want === 'rust')
+                picked = await tryCargo();
+            else {
+                picked = (await tryNpm()) ?? (await tryPy()) ?? (await tryGo()) ?? (await tryCargo());
+            }
+            if (!picked) {
+                return { dependencies: [] };
+            }
+            return {
+                ecosystem: picked.deps[0]?.ecosystem,
+                source: picked.source,
+                dependencies: picked.deps.slice(0, max),
+            };
+        });
+    },
+});

package/dist/tools/search/glob.d.ts

@@ -0,0 +1,26 @@
+/**
+ * glob — find files matching a pattern. Bounded output.
+ */
+import { z } from 'zod';
+declare const InputSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface GlobOutput {
+    pattern: string;
+    matches: string[];
+    truncated: boolean;
+}
+export declare const globTool: import("../types.js").Tool<{
+    pattern: string;
+    cwd?: string | undefined;
+    maxResults?: number | undefined;
+}, {
+    pattern: string;
+    matches: string[];
+    truncated: false;
+}>;
+export declare function globToRegex(pattern: string): RegExp;
+export type GlobInput = z.infer<typeof InputSchema>;
+export {};

package/dist/tools/search/glob.js

@@ -0,0 +1,88 @@
+/**
+ * glob — find files matching a pattern. Bounded output.
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    pattern: z.string().min(1).describe('Glob pattern, e.g. "**/*.ts" or "src/**/*.json"'),
+    cwd: z.string().optional().describe('Base directory; defaults to workspace cwd'),
+    maxResults: z.number().int().min(1).max(10_000).optional().describe('Cap results (default 1000)'),
+});
+const DEFAULT_MAX = 1000;
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', 'coverage', '.klyro']);
+export const globTool = defineTool({
+    name: 'glob',
+    description: 'Find files matching a glob pattern. Standard glob syntax (** for recursion, * for any segment). Skips common build dirs.',
+    inputSchema: InputSchema,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const base = input.cwd ? resolveWithinCwd(ctx.cwd, input.cwd).resolved : ctx.cwd;
+            const matcher = globToRegex(input.pattern);
+            const max = input.maxResults ?? DEFAULT_MAX;
+            const matches = [];
+            let truncated = false;
+            await walk(base, base, matcher, max + 1, matches, () => (truncated = true));
+            // Normalize to relative, forward-slash paths from ctx.cwd (so
+            // tool inputs/outputs are stable across Windows and POSIX).
+            const rel = matches.slice(0, max).map((m) => path.relative(ctx.cwd, m).split(path.sep).join('/'));
+            return { pattern: input.pattern, matches: rel, truncated };
+        });
+    },
+});
+export function globToRegex(pattern) {
+    // Convert glob to regex. Special-cases: a leading `**/` should match
+    // zero or more path segments (so `**/*.ts` matches both `a.ts` and
+    // `sub/a.ts`), and a bare `**` should match anything including paths
+    // with no separators.
+    let p = pattern;
+    const anchor = p.startsWith('**/') ? '^(?:.*/)?' : p === '**' ? '^.*' : '^';
+    if (p.startsWith('**/'))
+        p = p.slice(3);
+    const escaped = p
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '::DOUBLESTAR::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DOUBLESTAR::/g, '.*');
+    return new RegExp(`${anchor}${escaped}$`);
+}
+async function walk(root, dir, matcher, cap, out, onCap) {
+    if (out.length >= cap)
+        return;
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (out.length >= cap)
+            return;
+        if (SKIP_DIRS.has(name))
+            continue;
+        const full = path.join(dir, name);
+        let isDir = false;
+        try {
+            const s = await fs.lstat(full);
+            if (s.isSymbolicLink())
+                continue; // skip symlinks for safety
+            isDir = s.isDirectory();
+        }
+        catch {
+            continue;
+        }
+        const rel = path.relative(root, full).split(path.sep).join('/');
+        if (matcher.test(rel)) {
+            out.push(full);
+            if (out.length >= cap)
+                onCap();
+        }
+        if (isDir)
+            await walk(root, full, matcher, cap, out, onCap);
+    }
+}