@denizokcu/haze 0.0.2 → 0.1.0

package/dist/core/session/sessionStore.js

@@ -0,0 +1,59 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'fs-extra';
+import { HAZE_DIR } from '../../config/paths.js';
+const DEFAULT_SESSIONS_DIR = path.join(HAZE_DIR, 'sessions');
+function cwdHash(cwd = process.cwd()) {
+    return crypto.createHash('sha256').update(path.resolve(cwd)).digest('hex').slice(0, 16);
+}
+function sessionDir(cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    return path.join(sessionsDir, cwdHash(cwd));
+}
+function sessionFile(id, cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    return path.join(sessionDir(cwd, sessionsDir), `${id}.jsonl`);
+}
+function newSessionId(now = new Date()) {
+    return now.toISOString().replace(/[:.]/g, '-');
+}
+export async function createSession(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const id = newSessionId();
+    const file = sessionFile(id, cwd, options.sessionsDir);
+    await fs.ensureDir(path.dirname(file));
+    await appendSessionEntry({ id, file, cwd }, { type: 'header', id, cwd, createdAt: new Date().toISOString(), hazeVersion: options.hazeVersion });
+    return { id, file, cwd };
+}
+export async function latestSession(cwd = process.cwd(), sessionsDir = DEFAULT_SESSIONS_DIR) {
+    const dir = sessionDir(cwd, sessionsDir);
+    const files = (await fs.readdir(dir).catch(() => []))
+        .filter(file => file.endsWith('.jsonl'))
+        .sort();
+    const latest = files.at(-1);
+    if (!latest)
+        return undefined;
+    const id = path.basename(latest, '.jsonl');
+    return { id, file: path.join(dir, latest), cwd: path.resolve(cwd) };
+}
+export async function appendSessionEntry(session, entry) {
+    await fs.ensureDir(path.dirname(session.file));
+    await fs.appendFile(session.file, `${JSON.stringify(entry)}\n`, 'utf8');
+}
+export async function readSessionEntries(session) {
+    const raw = await fs.readFile(session.file, 'utf8');
+    return raw.split('\n').filter(Boolean).flatMap(line => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export async function restoreConversation(session) {
+    const entries = await readSessionEntries(session);
+    const snapshots = entries.filter((entry) => entry.type === 'conversation_snapshot');
+    return snapshots.at(-1)?.messages ?? [];
+}
+export function formatSession(session) {
+    return `${session.id} · ${session.file}`;
+}

package/dist/core/subagent/subagentRunner.d.ts

@@ -0,0 +1,33 @@
+import { streamText } from 'ai';
+import type { ContextFile } from '../../config/contextFiles.js';
+export interface SubagentResult {
+    status: 'ok' | 'error' | 'timeout' | 'cancelled';
+    summary: string;
+    toolCalls: Array<{
+        name: string;
+        summary: string;
+        durationMs: number;
+    }>;
+    toolCallCount: number;
+    tokens: {
+        in: number;
+        out: number;
+    };
+    durationMs: number;
+    error?: string;
+}
+export declare function runSubagent(task: string, options: {
+    model: Parameters<typeof streamText>[0]['model'];
+    contextFiles: ContextFile[];
+    allowedTools?: readonly string[];
+    maxSteps?: number;
+    abortSignal?: AbortSignal;
+}): Promise<SubagentResult>;
+export declare function createSubagentTool(options: {
+    model: Parameters<typeof streamText>[0]['model'];
+    contextFiles: ContextFile[];
+}): import("ai").Tool<{
+    task: string;
+    tools?: ("editFile" | "replaceLines" | "writeFile" | "listFiles" | "readFile" | "grep" | "bash")[] | undefined;
+    maxSteps?: number | undefined;
+}, SubagentResult>;

package/dist/core/subagent/subagentRunner.js

@@ -0,0 +1,140 @@
+import { streamText, stepCountIs, tool } from 'ai';
+import { z } from 'zod';
+import { buildSystemPrompt } from '../../llm/systemPrompt.js';
+import { hazeTools } from '../../llm/hazeTools.js';
+const SUBAGENT_SYSTEM_PROMPT = `You are a focused subagent. Complete the assigned task using all tools available to you, then return a clear summary.
+
+Rules:
+- Use whatever tools you need. You have full access to file tools and bash.
+- If the task requires creating or modifying files, do it directly — do not ask for permission.
+- If a tool fails, read the file again and retry with the correct content.
+- After completing the task, summarize what you did, what files you created or changed, and any important findings.
+- If you cannot complete the task, explain exactly what blocked you and what you tried.
+- Your summary is all the parent agent will see. Be specific: include file paths, function names, and concrete results.`;
+const ALL_TOOLS = ['listFiles', 'readFile', 'grep', 'bash', 'editFile', 'replaceLines', 'writeFile'];
+const STEP_LIMIT = 25;
+const MAX_SUMMARY = 4000;
+const TOOL_ONLY_LIMIT = 12;
+function toolSummary(output) {
+    if (typeof output !== 'object' || output == null)
+        return 'completed';
+    const o = output;
+    if (typeof o.totalMatches === 'number')
+        return o.totalMatches === 0 ? 'no matches' : `${o.totalMatches} matches`;
+    if (typeof o.code === 'number')
+        return `exit ${o.code}`;
+    if (o.ok === true)
+        return 'completed';
+    if (o.ok === false && typeof o.error === 'string')
+        return `failed: ${o.error.slice(0, 120)}`;
+    return 'completed';
+}
+function toolOnlyStepCount(steps) {
+    let count = 0;
+    for (const step of [...steps].reverse()) {
+        if (step.toolCalls.length === 0 || step.text.trim().length > 0)
+            break;
+        count += 1;
+    }
+    return count;
+}
+export async function runSubagent(task, options) {
+    const start = performance.now();
+    const toolNames = (options.allowedTools ?? ALL_TOOLS).filter(t => ALL_TOOLS.includes(t));
+    const maxSteps = Math.min(options.maxSteps ?? STEP_LIMIT, STEP_LIMIT);
+    const scopedTools = {};
+    for (const name of toolNames) {
+        const key = name;
+        if (key in hazeTools)
+            scopedTools[name] = hazeTools[key];
+    }
+    const toolCallLog = [];
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let lastStep = 0;
+    let totalToolCalls = 0;
+    try {
+        const result = streamText({
+            model: options.model,
+            temperature: 0,
+            maxOutputTokens: 4096,
+            system: `${SUBAGENT_SYSTEM_PROMPT}\n\n${buildSystemPrompt(options.contextFiles)}`,
+            messages: [{ role: 'user', content: task }],
+            tools: scopedTools,
+            stopWhen: stepCountIs(maxSteps),
+            abortSignal: options.abortSignal,
+            experimental_context: { inFlightToolCalls: new Map() },
+            prepareStep({ steps }) {
+                const calls = steps.flatMap(step => step.toolCalls);
+                const consecutiveToolOnly = toolOnlyStepCount(steps);
+                if (consecutiveToolOnly >= TOOL_ONLY_LIMIT || calls.length >= maxSteps * 2) {
+                    return {
+                        toolChoice: 'none',
+                        messages: [
+                            { role: 'user', content: 'You have done enough tool work. Summarize what you found or did right now.' },
+                        ],
+                    };
+                }
+                return undefined;
+            },
+            onStepFinish({ stepNumber }) {
+                lastStep = stepNumber;
+            },
+            onFinish(event) {
+                if (event.usage) {
+                    tokensIn = event.usage.inputTokens ?? 0;
+                    tokensOut = event.usage.outputTokens ?? 0;
+                }
+            },
+            experimental_onToolCallFinish(event) {
+                if (!event.toolCall)
+                    return;
+                totalToolCalls += 1;
+                toolCallLog.push({
+                    name: event.toolCall.toolName,
+                    summary: toolSummary(event.output),
+                    durationMs: event.durationMs,
+                });
+            },
+        });
+        let text = '';
+        for await (const delta of result.textStream) {
+            text += delta;
+        }
+        await result.response;
+        const summary = (text.trim() || 'Subagent completed without text output.').slice(0, MAX_SUMMARY);
+        const durationMs = performance.now() - start;
+        const status = options.abortSignal?.aborted ? 'cancelled'
+            : lastStep >= maxSteps ? 'timeout'
+                : 'ok';
+        return { status, summary, toolCalls: toolCallLog, toolCallCount: totalToolCalls, tokens: { in: tokensIn, out: tokensOut }, durationMs };
+    }
+    catch (error) {
+        return {
+            status: options.abortSignal?.aborted ? 'cancelled' : 'error',
+            summary: error instanceof Error ? error.message : String(error),
+            toolCalls: toolCallLog,
+            toolCallCount: totalToolCalls,
+            tokens: { in: tokensIn, out: tokensOut },
+            durationMs: performance.now() - start,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function createSubagentTool(options) {
+    return tool({
+        description: 'Spawn subagents to run independent tasks in parallel. ONLY use when a request clearly decomposes into 2+ independent subtasks that can run concurrently — spawn all of them in one step. Do NOT use for single tasks, sequential work, or anything that benefits from conversation context; do those directly instead. Subagents have no conversation history and return a summary.',
+        inputSchema: z.object({
+            task: z.string().min(1).describe('Clear, specific task for the subagent to complete.'),
+            tools: z.array(z.enum(['listFiles', 'readFile', 'grep', 'bash', 'editFile', 'replaceLines', 'writeFile'])).optional().describe('Tools the subagent can use. Defaults to all tools. Restrict to a subset only when the subagent should be read-only.'),
+            maxSteps: z.number().int().positive().max(50).optional().describe('Maximum tool-call rounds. Default 25.'),
+        }),
+        execute: async ({ task, tools, maxSteps }, context) => runSubagent(task, {
+            model: options.model,
+            contextFiles: options.contextFiles,
+            allowedTools: tools,
+            maxSteps,
+            abortSignal: context.abortSignal,
+        }),
+    });
+}

package/dist/llm/client.d.ts

@@ -1 +1 @@
-export declare function model(): Promise<import("@ai-sdk/provider").LanguageModelV3 | null>;
+export declare function model(): Promise<import("@ai-sdk/provider").LanguageModelV3>;

package/dist/llm/client.js

@@ -1,11 +1,11 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import { readSettings } from '../config/settings.js';
+import { activeModel } from '../config/providers.js';
 export async function model() {
     const settings = await readSettings();
-    const baseURL = process.env.OPENAI_BASE_URL ?? settings.baseURL;
-    const apiKey = process.env.OPENAI_API_KEY ?? settings.apiKey;
-    const name = process.env.HAZE_MODEL ?? settings.model ?? 'x-ai/grok-build-0.1';
-    if (!apiKey)
-        return null;
-    return createOpenAI({ apiKey, baseURL })(name);
+    const selection = activeModel(settings);
+    const baseURL = process.env.OPENAI_BASE_URL ?? selection.provider.url;
+    const apiKey = process.env.OPENAI_API_KEY ?? selection.provider.key ?? settings.apiKey ?? 'not-needed';
+    const name = process.env.HAZE_MODEL ?? selection.model;
+    return createOpenAI({ apiKey, baseURL }).chat(name);
 }

package/dist/llm/hazeTools.d.ts

@@ -1,3 +1,9 @@
+type ToolDiffLine = {
+    type: 'add' | 'remove' | 'context';
+    oldLine?: number;
+    newLine?: number;
+    text: string;
+};
 export declare const hazeTools: {
     listFiles: import("ai").Tool<{
         path: string;
@@ -6,6 +12,13 @@ export declare const hazeTools: {
         includeIgnored: boolean;
         cursor?: string | undefined;
     }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
         ok: true;
         duplicateSkipped: true;
         toolName: string;
@@ -30,6 +43,13 @@ export declare const hazeTools: {
         offset?: number | undefined;
         limit?: number | undefined;
     }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
         ok: true;
         duplicateSkipped: true;
         toolName: string;
@@ -53,6 +73,39 @@ export declare const hazeTools: {
         totalLines: number;
         lineNumberedText: string;
     }>;
+    grep: import("ai").Tool<{
+        pattern: string;
+        path: string;
+        contextLines: number;
+        maxMatches: number;
+        caseInsensitive: boolean;
+        glob?: string | undefined;
+    }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
+        ok: true;
+        duplicateSkipped: true;
+        toolName: string;
+        reason: string;
+    } | {
+        pattern: string;
+        path: string;
+        glob: string | null;
+        caseInsensitive: boolean;
+        matches: {
+            file: string;
+            line: number;
+            content: string;
+            isContext: boolean;
+        }[];
+        totalMatches: number;
+        truncated: boolean;
+    }>;
     replaceLines: import("ai").Tool<{
         path: string;
         startLine: number;
@@ -60,6 +113,13 @@ export declare const hazeTools: {
         content: string;
         allowIgnored: boolean;
     }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
         ok: true;
         duplicateSkipped: true;
         toolName: string;
@@ -69,8 +129,14 @@ export declare const hazeTools: {
         path: string;
         startLine: number;
         endLine: number;
+        requestedEndLine: number;
+        endLineClamped: boolean;
         replacementLines: number;
         appended: boolean;
+        addedLines: number;
+        removedLines: number;
+        diffLineCount: number;
+        diff: ToolDiffLine[] | undefined;
     }>;
     writeFile: import("ai").Tool<{
         path: string;
@@ -78,6 +144,13 @@ export declare const hazeTools: {
         overwriteExisting: boolean;
         allowIgnored: boolean;
     }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
         ok: true;
         duplicateSkipped: true;
         toolName: string;
@@ -96,6 +169,13 @@ export declare const hazeTools: {
         }[];
         allowIgnored: boolean;
     }, {
+        ok: boolean;
+        toolName: string;
+        path: string | undefined;
+        error: string;
+        recoverable: boolean;
+        suggestedNextStep: string;
+    } | {
         ok: true;
         duplicateSkipped: true;
         toolName: string;
@@ -104,6 +184,11 @@ export declare const hazeTools: {
         ok: boolean;
         path: string;
         edits: number;
+        approximateMatches: number;
+        addedLines: number;
+        removedLines: number;
+        diffLineCount: number;
+        diff: ToolDiffLine[] | undefined;
     }>;
     bash: import("ai").Tool<{
         command: string;
@@ -112,3 +197,4 @@ export declare const hazeTools: {
     }, unknown>;
 };
 export type HazeTools = typeof hazeTools;
+export {};