glitool 1.0.0

package/README.md

@@ -0,0 +1,45 @@
+# glitool
+
+AI coding assistant for your terminal. Powered by OpenAI.
+
+
+## Install
+
+```bash
+npm install -g glitool
+```
+
+## Setup
+
+On first run, glitool will ask for your OpenAI API key. Get one at https://platform.openai.com/api-keys
+
+Or set it manually:
+
+```bash
+mkdir ~/.glitool
+echo "OPENAI_API_KEY=sk-..." > ~/.glitool/.env
+```
+
+## Usage
+
+```bash
+glitool              # start AI chat session
+glitool --explain    # explain every change in simple language
+glitool config --set-name "Your Name"
+glitool config --set-model gpt-4o
+glitool config --show
+```
+
+## Commands (inside chat)
+
+| Command | Description |
+|---------|-------------|
+| /help   | Show available commands |
+| /clear  | Clear current session |
+| /reset  | Clear session + memory |
+| /exit   | Save and exit |
+
+## Requirements
+
+- Node.js 18+
+- OpenAI API key

package/dist/agent.js

@@ -0,0 +1,115 @@
+import { writeFileTool, analyzeProjectTool, listFilesTool, readFileTool, searchCodeTool, editFileTool } from "./tools/index.js";
+import { AIMessage, BaseMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
+import { StructuredTool } from "@langchain/core/tools";
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { ChatOpenAI } from '@langchain/openai';
+import { loadSession, loadSummary, saveSession, generateAndSaveSummary } from "./memory.js";
+import { loadConfig } from "./config.js";
+import { loadProjectMemory } from "./projectMemory.js";
+import { config as loadEnv } from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { detectComplexity } from './llm/router.js';
+import { runAgentGraph } from "./agents/graph.js";
+import os from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+loadEnv({ path: join(os.homedir(), '.glitool', '.env') });
+const simpleLlm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+export const llm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+const config = loadConfig();
+const tools = [listFilesTool, readFileTool, searchCodeTool, writeFileTool, analyzeProjectTool, editFileTool];
+export const sessionMessages = loadSession();
+export function clearSession() {
+    sessionMessages.length = 0;
+    saveSession(sessionMessages);
+}
+function buildSystemPrompt() {
+    let summary = loadSummary();
+    const project = loadProjectMemory();
+    if (!summary) {
+        const rawSession = loadSession();
+        if (rawSession.length > 4) {
+            generateAndSaveSummary(rawSession, llm);
+            summary = loadSummary();
+        }
+    }
+    // const project = loadProjectMemory();
+    let prompt = `You are an expert coding assistant. Be concise and code-focused.
+IMPORTANT: If any tool returns USER_CANCELLED, immediately stop all tool calls and tell the user the operation was cancelled. Never retry a cancelled operation.`;
+    if (summary)
+        prompt += `\n\nPrevious session summary:\n${summary}`;
+    if (project)
+        prompt += `\n\nProject facts:\n${JSON.stringify(project, null, 2)}`;
+    return prompt;
+}
+const systemPrompt = await buildSystemPrompt();
+const simpleAgent = createReactAgent({
+    llm: simpleLlm,
+    tools,
+    stateModifier: new SystemMessage(buildSystemPrompt())
+});
+const complexAgent = createReactAgent({
+    llm,
+    tools,
+    stateModifier: new SystemMessage(buildSystemPrompt())
+});
+export async function chat(userInput, onToolCall, onStatus, onToken) {
+    const complexity = detectComplexity(userInput);
+    sessionMessages.push(new HumanMessage(userInput));
+    if (complexity === 'complex') {
+        const result = await runAgentGraph(userInput, buildSystemPrompt(), onToolCall, onStatus ?? (() => { }));
+        if (result !== null && result !== undefined) {
+            sessionMessages.push(new AIMessage(result));
+            saveSession(sessionMessages);
+            return result;
+        }
+    }
+    ;
+    const eventStrem = simpleAgent.streamEvents({ messages: sessionMessages }, { version: 'v2' });
+    let finalResponse = '';
+    for await (const { event, data, name: eventName } of eventStrem) {
+        if (event === 'on_chat_model_stream') {
+            const chunk = data.chunk;
+            let token = '';
+            if (typeof chunk?.content === 'string') {
+                token = chunk.content;
+            }
+            else if (Array.isArray(chunk?.content)) {
+                token = chunk.content.filter((c) => c.type === 'text').map((c) => c.text ?? '').join('');
+            }
+            if (token) {
+                onToken?.(token);
+                finalResponse += token;
+            }
+            // const token = data.chunk?.content;
+            // if(token && typeof token === 'string'){
+            //     onToken?.(token);
+            //     finalResponse += token;
+            // }
+        }
+        if (event === 'on_tool_start') {
+            onToolCall(eventName, data.input);
+        }
+        if (event === 'on_chat_model_end') {
+            if (!finalResponse) {
+                const output = data.output;
+                if (typeof output?.content === 'string') {
+                    finalResponse = output.content;
+                    onToken?.(finalResponse);
+                }
+            }
+        }
+    }
+    if (finalResponse) {
+        sessionMessages.push(new AIMessage(finalResponse));
+    }
+    saveSession(sessionMessages);
+    return finalResponse;
+}

package/dist/agents/coder.js

@@ -0,0 +1,54 @@
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { ChatOpenAI } from "@langchain/openai";
+import { SystemMessage, HumanMessage, BaseMessage } from "@langchain/core/messages";
+import { StructuredTool } from "@langchain/core/tools";
+import { listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool } from '../tools/index.js';
+import { scoreRisk, getRiskMessage } from "../trust/riskScorer.js";
+import { requestConfirm } from "../confirmHandler.js";
+const coderLlm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+const coderAgent = createReactAgent({
+    llm: coderLlm,
+    tools: [listFilesTool, readFileTool, searchCodeTool, editFileTool, writeFileTool],
+    stateModifier: new SystemMessage('You are a coding execution agent. Execute the given plan step by step using tools. Be precise and thorough.')
+});
+export async function runCoder(plan, userMessage, onToolCall) {
+    const stream = await coderAgent.stream({
+        messages: [new HumanMessage(`Plan to execute:\n${plan}\n\nOriginal request: ${userMessage}`)]
+    });
+    let result = '';
+    for await (const chunk of stream) {
+        if (chunk.agent?.messages) {
+            const msgs = chunk.agent.messages;
+            const msg = msgs.at(-1);
+            if (msg?.tool_calls?.length > 0) {
+                const toolCall = msg.tool_calls[0];
+                const risk = scoreRisk(toolCall.name, toolCall.args);
+                const riskMsg = getRiskMessage(toolCall.name, risk, toolCall.args);
+                if (risk === 'high') {
+                    onToolCall(toolCall.name, toolCall.args);
+                    result = `Blocked: I cannot write to sensitive files like ${toolCall.args?.filePath}.`;
+                    break;
+                }
+                onToolCall(toolCall.name, toolCall.args);
+            }
+            else if (msg?.content) {
+                result = msg.content;
+            }
+        }
+    }
+    // for await (const chunk of stream){
+    //     if(chunk.agent?.messages){
+    //         const msgs = chunk.agent.messages as BaseMessage[];
+    //         const msg = msgs.at(-1);
+    //         if((msg as any)?.tool_calls?.length > 0){
+    //             onToolCall((msg as any).tool_calls[0].name, (msg as any).tool_calls[0].args);
+    //         }else if (msg?.content){
+    //             result = msg.content as string;
+    //         }
+    //     }
+    // }
+    return result;
+}

package/dist/agents/explainer.js

@@ -0,0 +1,20 @@
+import { ChatOpenAI } from "@langchain/openai";
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+const explainerLlm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+export async function explainResponse(response) {
+    if (!response || response.length < 50)
+        return '';
+    const result = await explainerLlm.invoke([
+        new SystemMessage(`You are a coding teacher. Give what an AI coding assistant just did, explain it in 2-4 simple sentences a biginner would underStand.     
+            Focus on:
+            - What changed and why
+            - What concept was used
+            - What to learn next
+            Keep it friendly and short.`),
+        new HumanMessage(`What was just done:\n${response}`)
+    ]);
+    return result.content;
+}

package/dist/agents/graph.js

@@ -0,0 +1,28 @@
+import { runPlanner } from './planner.js';
+import { runCoder } from './coder.js';
+import { runReviewer } from './reviewer.js';
+const MAX_ITERATIONS = 1;
+export async function runAgentGraph(userMessage, systemPrompt, onToolCall, onStatus) {
+    onStatus('Planning...');
+    const plan = await runPlanner(userMessage, systemPrompt);
+    if (plan.trim() === 'SIMPLE') {
+        return '';
+    }
+    let coderOutPut = '';
+    let finalResponse = '';
+    let approved = false;
+    let iteration = 0;
+    while (!approved && iteration < MAX_ITERATIONS) {
+        onStatus(`Executing plan${iteration > 0 ? ' (fixing issues)' : ''}...`);
+        coderOutPut = await runCoder(plan, userMessage, onToolCall);
+        onStatus('Reviewing...');
+        const review = await runReviewer(plan, coderOutPut, userMessage);
+        approved = review.approved;
+        finalResponse = review.finalResponse;
+        if (!approved) {
+            onStatus(`Reviewer founder issues: ${review.feedback}`);
+        }
+        iteration++;
+    }
+    return finalResponse || coderOutPut;
+}

package/dist/agents/planner.js

@@ -0,0 +1,18 @@
+import { ChatOpenAI } from "@langchain/openai";
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+const plannerLlm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+export async function runPlanner(userMessage, context) {
+    const response = await plannerLlm.invoke([
+        new SystemMessage(`You are a coding task planner. Given a user request, output a clear numbered plan.
+Rules:
+- Be specific about which files to read, edit, or create
+- Do NOT write any code — only plan the steps
+- Keep it to 3-6 steps maximum
+- If the task is a simple question or explanation (not a coding task), output exactly: SIMPLE`),
+        new HumanMessage(`Context:\n${context}\n\nUser request: ${userMessage}`)
+    ]);
+    return response.content;
+}

package/dist/agents/reviewer.js

@@ -0,0 +1,25 @@
+import { ChatOpenAI } from "@langchain/openai";
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+const reviewerLlm = new ChatOpenAI({
+    model: 'gpt-4o-mini',
+    apiKey: process.env.OPENAI_API_KEY
+});
+export async function runReviewer(plan, coderOutput, userMessage) {
+    const response = await reviewerLlm.invoke([
+        new SystemMessage(`You are a code reviewer. check if the coder's work correctly fulfills the user's request. Return valid JSON only:
+            {
+                "approved":true or false,
+                "feedback": "what needs fixing if not approved, otherwise empty string",
+                "finalResponse": "the final message to show the user summarizing what was done"
+            
+            }`),
+        new HumanMessage(`User request: ${userMessage}\n\nPlan:\n${plan}\n\nWhat was done:\n${coderOutput}`)
+    ]);
+    try {
+        const cleaned = response.content.replace(/```json|```/g, '').trim();
+        return JSON.parse(cleaned);
+    }
+    catch {
+        return { approved: true, feedback: '', finalResponse: coderOutput };
+    }
+}

package/dist/config.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const CONFIG_PATH = path.join(os.homedir(), '.glitool', 'config.json');
+const DEFAULTS = {
+    name: 'Developer',
+    preferredLanguage: 'TypeScript',
+    codingStyle: 'spaces',
+    preferredModel: 'gpt-4o-mini'
+};
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_PATH))
+            return DEFAULTS;
+        const data = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+        return { ...DEFAULTS, ...data };
+    }
+    catch {
+        return DEFAULTS;
+    }
+}
+export function saveConfig(config) {
+    const current = loadConfig();
+    const updated = { ...current, ...config };
+    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(updated, null, 2), 'utf-8');
+}

package/dist/confirmHandler.js

@@ -0,0 +1,7 @@
+let handler = async () => true;
+export function setConfirmHandler(fn) {
+    handler = fn;
+}
+export function requestConfirm(message) {
+    return handler(message);
+}

package/dist/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from "commander";
+import { config as dotenvConfig } from "dotenv";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { readFileSync } from "fs";
+import { render } from "ink";
+import { App } from "./ui/App.js";
+import { loadConfig, saveConfig } from "./config.js";
+import { generateAndSaveSummary } from "./memory.js";
+import { llm, sessionMessages } from "./agent.js";
+import { extractAndSaveProjectMemory } from "./projectMemory.js";
+import os from 'os';
+import { createInflate } from "zlib";
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { createInterface } from "readline";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+dotenvConfig({ path: join(os.homedir(), '.glitool', '.env') });
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const program = new Command();
+let explainMode = false;
+program
+    .name('glitool')
+    .description('A CLI tool for glitool')
+    .version(pkg.version);
+program
+    .command('hello')
+    .description('Say hello')
+    .argument('<name>', 'Name to greet')
+    .option('-s, --shout', 'Shout the greeting')
+    .action((name, option) => {
+    const msg = `Hello, ${name}!`;
+    console.log(option.shout ? msg.toUpperCase() : msg);
+});
+program
+    .command('config')
+    .description('Manage Your glitool profile')
+    .option('--set-name <name>', 'set your name')
+    .option('--set-language <lang>', 'Set preferred language')
+    .option('--set-style <style>', 'set coding style (tabs or spaces)')
+    .option('--set-model <model>', 'Set preferred model')
+    .option('--show', 'Show current config')
+    .action((options) => {
+    if (options.show) {
+        const cfg = loadConfig();
+        console.log(JSON.stringify(cfg, null, 2));
+        return;
+    }
+    if (options.setName)
+        saveConfig({ name: options.setName });
+    if (options.setLanguage)
+        saveConfig({ preferredLanguage: options.setLanguage });
+    if (options.setStyle)
+        saveConfig({ codingStyle: options.setStyle });
+    if (options.setModel)
+        saveConfig({ preferredModel: options.setModel });
+    console.log('Config updated');
+});
+program
+    .option('-e, --explain', 'Explain every change in simple language')
+    .action((options) => {
+    explainMode = options.explain ?? false;
+});
+async function ensureApiKey() {
+    if (process.env.OPENAI_API_KEY)
+        return;
+    const envPath = join(os.homedir(), '.glitool', '.env');
+    if (existsSync(envPath)) {
+        dotenvConfig({ path: envPath });
+        if (process.env.OPENAI_API_KEY)
+            return;
+    }
+    console.log('\nNo OpenAI API key found.');
+    console.log('Get one at https://platform.openai.com/api-keys\n');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const key = await new Promise(resolve => rl.question('Paste your API key: ', resolve));
+    rl.close();
+    if (!key.trim()) {
+        console.log('No key entered. Exiting.');
+        process.exit(1);
+    }
+    mkdirSync(join(os.homedir(), '.glitool'), { recursive: true });
+    writeFileSync(envPath, `OPENAI_API_KEY=${key.trim()}\n`, 'utf-8');
+    process.env.OPENAI_API_KEY = key.trim();
+    console.log('API key saved to ~/.glitool/.env\n');
+}
+const saveAndExit = async () => {
+    await generateAndSaveSummary(sessionMessages, llm);
+    await extractAndSaveProjectMemory(sessionMessages, llm);
+    process.exit(0);
+};
+process.on('SIGINT', saveAndExit);
+process.on('SIGTERM', saveAndExit);
+await ensureApiKey();
+if (process.argv.length === 2 || process.argv.includes('--explain') || process.argv.includes('-e')) {
+    explainMode = process.argv.includes('--explain') || process.argv.includes('-e');
+    const { waitUntilExit } = render(_jsx(App, { explainMode: explainMode }));
+    await waitUntilExit();
+    // const { waitUntilExit } = render(<App/>)
+    // await waitUntilExit()
+}
+else {
+    program.parse();
+}

package/dist/llm/router.js

@@ -0,0 +1,25 @@
+const SIMPLE_PATTERNS = [
+    /^(what|who|when|where|how|why)\s.{0,60}\?$/i,
+    /^(explain|define|what is|what are|tell me about)\s/i,
+    /^(hi|hello|hey|thanks|thank you)/i,
+    /^\/\w+/,
+];
+const COMPLEX_PATTERNS = [
+    /refactor|rewrite|redesign/i,
+    /implement|build|create|add|generate/i,
+    /fix|debug|solve|resolve/i,
+    /optimize|improve|upgrade/i,
+    /migrate|convert|transform/i,
+];
+export function detectComplexity(message) {
+    const trimmed = message.trim();
+    for (const pattern of SIMPLE_PATTERNS) {
+        if (pattern.test(trimmed))
+            return 'simple';
+    }
+    for (const pattern of COMPLEX_PATTERNS) {
+        if (pattern.test(trimmed))
+            return 'complex';
+    }
+    return trimmed.length > 120 ? 'complex' : 'simple';
+}

package/dist/memory.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { BaseMessage, HumanMessage, SystemMessage, AIMessage, ToolMessage } from '@langchain/core/messages';
+const SESSIONS_DIR = path.join(os.homedir(), '.glitool', 'sessions');
+const SUMMARY_SUFFIX = '.summary.md';
+const MAX_SAVED_MESSAGES = 40;
+function getSessionPath() {
+    const projectHash = crypto.createHash('md5').update(process.cwd()).digest('hex').slice(0, 8);
+    return path.join(SESSIONS_DIR, `${projectHash}.json`);
+}
+function serialize(messages) {
+    return messages.filter(m => {
+        if (m instanceof ToolMessage)
+            return false;
+        if (m instanceof AIMessage && !m.content)
+            return false;
+        return true;
+    })
+        .map(m => {
+        if (m instanceof HumanMessage)
+            return { type: 'human', content: m.content };
+        if (m instanceof AIMessage)
+            return { type: 'ai', content: m.content };
+        return { type: 'system', content: m.content };
+    });
+}
+function deserialize(data) {
+    return data.map(m => {
+        if (m.type === 'human')
+            return new HumanMessage(m.content);
+        if (m.type === 'ai')
+            return new AIMessage(m.content);
+        if (m.type === 'tool')
+            return new ToolMessage({ content: m.content, tool_call_id: m.tool_call_id ?? '' });
+        return new SystemMessage(m.content);
+    });
+}
+export function loadSession() {
+    try {
+        const file = getSessionPath();
+        if (!fs.existsSync(file))
+            return [];
+        const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        return deserialize(data);
+    }
+    catch {
+        return [];
+    }
+}
+export function saveSession(messages) {
+    try {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        const trimmed = messages.slice(-MAX_SAVED_MESSAGES);
+        fs.writeFileSync(getSessionPath(), JSON.stringify(serialize(trimmed), null, 2), 'utf-8');
+    }
+    catch {
+        //no-critical
+    }
+}
+export function loadSummary() {
+    try {
+        const hash = crypto.createHash('md5').update(process.cwd()).digest('hex').slice(0, 8);
+        const file = path.join(SESSIONS_DIR, `${hash}${SUMMARY_SUFFIX}`);
+        if (!fs.existsSync(file))
+            return null;
+        return fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function generateAndSaveSummary(messages, llm) {
+    const readable = messages
+        .filter(m => m instanceof HumanMessage || (m instanceof AIMessage && m.content))
+        .map(m => `${m instanceof HumanMessage ? 'User' : 'Assistant'}: ${m.content}`)
+        .join('\n');
+    if (!readable.trim())
+        return;
+    const response = await llm.invoke([
+        new SystemMessage('Summarize this coding session in 2-3 sentences. Focus on: what was built, what decisions ware made, and what the next step is.'),
+        new HumanMessage(readable)
+    ]);
+    const hash = crypto.createHash('md5').update(process.cwd()).digest('hex').slice(0, 8);
+    const file = path.join(SESSIONS_DIR, `${hash}${SUMMARY_SUFFIX}`);
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    fs.writeFileSync(file, response.content, 'utf-8');
+}
+export function clearSummary() {
+    try {
+        const hash = crypto.createHash('md5').update(process.cwd()).digest('hex').slice(0, 8);
+        const file = path.join(SESSIONS_DIR, `${hash}.summary.md`);
+        if (fs.existsSync(file))
+            fs.unlinkSync(file);
+    }
+    catch { }
+}

package/dist/projectMemory.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import path from 'path';
+import { HumanMessage, AIMessage, SystemMessage, BaseMessage } from '@langchain/core/messages';
+const MEMORY_PATH = path.join(process.cwd(), '.glitool', 'memory.json');
+export function loadProjectMemory() {
+    try {
+        if (!fs.existsSync(MEMORY_PATH))
+            return null;
+        return JSON.parse(fs.readFileSync(MEMORY_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveProjectMemory(memory) {
+    try {
+        fs.mkdirSync(path.dirname(MEMORY_PATH), { recursive: true });
+        fs.writeFileSync(MEMORY_PATH, JSON.stringify(memory, null, 2), 'utf-8');
+    }
+    catch { }
+}
+export async function extractAndSaveProjectMemory(messages, llm) {
+    const readable = messages
+        .filter(m => m instanceof HumanMessage || (m instanceof AIMessage && m.content))
+        .slice(-20)
+        .map(m => `${m instanceof HumanMessage ? 'User' : 'Assistant'}: ${m.content}`)
+        .join('\n');
+    if (!readable.trim())
+        return;
+    const existing = loadProjectMemory();
+    const response = await llm.invoke([
+        new SystemMessage(`Extract structured project facts from this conversation. return valid JSON only:
+            {
+            "techStack": ["languages, frameworks, libraries mentioned"],
+            "architectureDecisions": ["key structural decisions made"],
+            "todos": ["next steps or TODOs mentioned"],
+            "lastUpdated": "${new Date().toISOString()}"
+            }
+            
+            ${existing ? `Merge with existing memory: ${JSON.stringify(existing)}` : ''}`),
+        new HumanMessage(readable)
+    ]);
+    try {
+        const cleaned = response.content.replace(/```json|```/g, '').trim();
+        saveProjectMemory(JSON.parse(cleaned));
+    }
+    catch { }
+}
+export function clearProjectMemory() {
+    try {
+        if (fs.existsSync(MEMORY_PATH))
+            fs.unlinkSync(MEMORY_PATH);
+    }
+    catch { }
+}

package/dist/readProject.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import { get } from 'http';
+import path from 'path';
+const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '.next'];
+const TEXT_EXTENSIONS = ['.ts', '.js', '.json', '.md', '.txt', '.tsx', '.jsx', '.css', '.html', '.env'];
+const MAX_FILE_SIZE = 50 * 1024; // 50kb
+function getFiles(dir, prefix = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const lines = [];
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            lines.push(`${prefix}${entry.name}/`);
+            lines.push(...getFiles(fullPath, prefix + '  '));
+        }
+        else {
+            lines.push(`${prefix}${entry.name}`);
+        }
+    }
+    return lines;
+}
+function getFileContents(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    let result = '';
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            result += getFileContents(fullPath);
+        }
+        else {
+            const ext = path.extname(entry.name);
+            if (!TEXT_EXTENSIONS.includes(ext))
+                continue;
+            const stats = fs.statSync(fullPath);
+            if (stats.size > MAX_FILE_SIZE)
+                continue;
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            result += `\n--- File: ${fullPath} ---\n${content}\n`;
+        }
+    }
+    return result;
+}
+export function getProjectContext(dir) {
+    const structure = getFiles(dir).join('\n');
+    const contents = getFileContents(dir);
+    return `Folder structure:\n${structure}\n\nFile contents:${contents}`;
+}

package/dist/tools/analyzeProject.js

@@ -0,0 +1,61 @@
+import { tool } from "@langchain/core/tools";
+import fs from 'fs';
+import path from 'path';
+import { execSync } from "child_process";
+import { z } from 'zod';
+const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '.next'];
+function getDependencyList() {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson.dependencies || {};
+}
+function checkForOutdatedDependencies() {
+    try {
+        const result = execSync('npm outdated --json', { timeout: 10000, stdio: 'pipe' }).toString();
+        return JSON.parse(result);
+    }
+    catch (error) {
+        return {};
+    }
+}
+function analyzeCodeQuality() {
+    try {
+        const result = execSync(`eslint . --format json`, { timeout: 10000, stdio: 'pipe' }).toString();
+        return JSON.parse(result);
+    }
+    catch (error) {
+        return { error: [], warnings: [] };
+    }
+}
+function getFiles(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...getFiles(fullPath));
+        }
+        else {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+export const analyzeProjectTool = tool(async () => {
+    const dependencies = getDependencyList();
+    const outdatedDependencies = checkForOutdatedDependencies();
+    const codeQualityResults = analyzeCodeQuality();
+    const projectFiles = getFiles(process.cwd());
+    return {
+        dependencies,
+        outdatedDependencies,
+        codeQualityResults,
+        projectFiles
+    };
+}, {
+    name: 'analyzeProject',
+    description: 'analyze the current project for dependencies, code quality , and  project structure . useful for getting an overview of the project and identifying potential issues.',
+    schema: z.object({})
+});

package/dist/tools/editFileTool.js

@@ -0,0 +1,28 @@
+import { tool } from "@langchain/core/tools";
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export const editFileTool = tool(async ({ filePath, oldString, newString }) => {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    if (!fullPath.startsWith(process.cwd())) {
+        throw new Error('Access denied: outside project root');
+    }
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    const content = fs.readFileSync(fullPath, 'utf-8');
+    if (!content.includes(oldString)) {
+        throw new Error(`String not found in file. Make sure oldString matches exactly, including whitespace and case.`);
+    }
+    const updated = content.replace(oldString, newString);
+    fs.writeFileSync(fullPath, updated, 'utf-8');
+    return `Successfully edited ${filePath}`;
+}, {
+    name: 'editFile',
+    description: 'Make a targeted edit to an existing file by replacing an exact string. Use readFile first to get the current content, then provide the exact oldString to replace.',
+    schema: z.object({
+        filePath: z.string().describe('Relative path to the file from the project root'),
+        oldString: z.string().describe('The exact string to find and replace - must match exactly including whitespace and indentation'),
+        newString: z.string().describe('The string to replace it with')
+    })
+});

package/dist/tools/index.js

@@ -0,0 +1,7 @@
+export { readProjectTool } from './readProject.js';
+export { writeFileTool } from './writeFileTool.js';
+export { analyzeProjectTool } from './analyzeProject.js';
+export { listFilesTool } from './listFilesTool.js';
+export { readFileTool } from './readFileTool.js';
+export { searchCodeTool } from './searchCodeTool.js';
+export { editFileTool } from './editFileTool.js';

package/dist/tools/listFilesTool.js

@@ -0,0 +1,27 @@
+import { tool } from '@langchain/core/tools';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '.next'];
+function buildTree(dir, prefix = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const lines = [];
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        if (entry.isSymbolicLink())
+            continue;
+        lines.push(`${prefix}${entry.isDirectory() ? '📁' : '📄'} ${entry.name}`);
+        if (entry.isDirectory()) {
+            const sub = buildTree(path.join(dir, entry.name), prefix + '  ');
+            if (sub)
+                lines.push(sub);
+        }
+    }
+    return lines.join('\n');
+}
+export const listFilesTool = tool(async () => buildTree(process.cwd()), {
+    name: 'listFiles',
+    description: 'Lists files and directories in the current working directory. It returns a tree-like structure with folders and files.',
+    schema: z.object({})
+});

package/dist/tools/readFileTool.js

@@ -0,0 +1,20 @@
+import { tool } from '@langchain/core/tools';
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+export const readFileTool = tool(async ({ filePath }) => {
+    const fullPath = path.resolve(process.cwd(), filePath);
+    if (!fullPath.startsWith(process.cwd())) {
+        throw new Error('Access denied: outside of current working directory');
+    }
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${filePath}`);
+    }
+    return fs.readFileSync(fullPath, 'utf-8');
+}, {
+    name: 'readFile',
+    description: 'Reads the contents of a specific file. Use this tool to read the contents of a file in the current working directory. Provide the relative path to the file you want to read.',
+    schema: z.object({
+        filePath: z.string().describe('Relative path to the file from the project root')
+    })
+});

package/dist/tools/readProject.js

@@ -0,0 +1,64 @@
+import { tool } from "@langchain/core/tools";
+import { z } from 'zod';
+import fs from 'fs';
+import path from 'path';
+const SKIP_DIRS = ['node_modules', '.git', 'dist', 'build', '.next'];
+const TEXT_EXTENSIONS = ['.ts', '.js', '.json', '.md', '.txt', '.tsx', '.jsx', '.css', '.html'];
+const SKIP_FILE_PREFIXES = ['.env'];
+const MAX_FILE_SIZE = 50 * 1024; // 50kb
+function getFiles(dir, prefix = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const lines = [];
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        if (entry.isSymbolicLink())
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            lines.push(`${prefix}${entry.name}/`);
+            lines.push(...getFiles(fullPath, prefix + '  '));
+        }
+        else {
+            lines.push(`${prefix}${entry.name}`);
+        }
+    }
+    return lines;
+}
+function getFileContents(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    let result = '';
+    for (const entry of entries) {
+        if (SKIP_DIRS.includes(entry.name))
+            continue;
+        if (SKIP_FILE_PREFIXES.some(p => entry.name.startsWith(p)))
+            continue;
+        if (entry.isSymbolicLink())
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            result += getFileContents(fullPath);
+        }
+        else {
+            const ext = path.extname(entry.name);
+            if (!TEXT_EXTENSIONS.includes(ext))
+                continue;
+            const stats = fs.statSync(fullPath);
+            if (stats.size > MAX_FILE_SIZE)
+                continue;
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            result += `\n--- File: ${fullPath} ---\n${content}\n`;
+        }
+    }
+    return result;
+}
+export const readProjectTool = tool(async () => {
+    const dir = process.cwd();
+    const structure = getFiles(dir).join('\n');
+    const contents = getFileContents(dir);
+    return `Folder structure:\n${structure}\n\nFile contents:${contents}`;
+}, {
+    name: 'readProject',
+    description: 'Read the current project structure and file contents. Useful for providing context to the assistant.',
+    schema: z.object({})
+});

package/dist/tools/searchCodeTool.js

@@ -0,0 +1,18 @@
+import { tool } from "@langchain/core/tools";
+import { execSync } from "child_process";
+import { z } from "zod";
+export const searchCodeTool = tool(async ({ keyword }) => {
+    try {
+        const result = execSync(`grep -rn "${keyword}" --include="*.ts" --include="*.js" --include="*.json" --exclude-dir=node_modules --exclude-dir=dist --exclude-dir=dist --exclude-dir=.git`, { cwd: process.cwd(), timeout: 10000, stdio: 'pipe' }).toString();
+        return result || 'No Matches found.';
+    }
+    catch {
+        return 'No matches found.';
+    }
+}, {
+    name: 'searchCode',
+    description: 'Search for a keyword or function name across all project files. Returns file paths and line numbers where the keyword is found. Use this tool to quickly locate where a specific function or variable is used in the codebase.',
+    schema: z.object({
+        keyword: z.string().describe('The Keyword, funtion name, or pattern to search for in the codebase')
+    })
+});

package/dist/tools/writeFileTool.js

@@ -0,0 +1,31 @@
+import { tool } from "@langchain/core/tools";
+import { confirm } from "@inquirer/prompts";
+import fs from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { requestConfirm } from "../confirmHandler.js";
+export const writeFileTool = tool(async ({ filePath, content }) => {
+    const projectRoot = process.cwd();
+    const fullPath = path.resolve(projectRoot, filePath);
+    if (!fullPath.startsWith(projectRoot + path.sep) && fullPath !== projectRoot) {
+        throw new Error('Access denied: cannot write outside project root');
+    }
+    console.log(`\n📄 Write to: ${filePath}`);
+    console.log('_'.repeat(40));
+    console.log(content.slice(0, 500) + (content.length > 500 ? '\n...(truncated)' : ''));
+    console.log('_'.repeat(40));
+    const ok = await requestConfirm(`Write to: ${filePath}?`);
+    if (!ok) {
+        return 'USER_CANCELLED: The user explicitly rejected this file write. Do NOT retry. Inform the user the write was cancelled.';
+    }
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content, 'utf-8');
+    return `File written: ${filePath}`;
+}, {
+    name: 'writeFile',
+    description: 'Create or overwrite a file with the given content. Always use editFile for modifying existing files - only use this to creat new files or completely replace files. Provide the relative file path and the full content to write.',
+    schema: z.object({
+        filePath: z.string().describe('Relative path to the file from the project root. For example: src/utils/helpers.ts'),
+        content: z.string().describe('The full content to write to the file. The agent should provide the complete content of the file, not just the changes. Use editFile for making targeted edits to existing files.')
+    })
+});

package/dist/trust/riskScorer.js

@@ -0,0 +1,25 @@
+const HIGH_RISK_PATTERNS = [
+    /\.env/,
+    /\.env\.\w+/,
+    /package\.json$/,
+    /tsconfig\.json$/,
+    /docker-compose/,
+    /\.git\//,
+];
+const LOW_RISK_TOOLS = ['listFiles', 'readFile', 'searchCode'];
+export function scoreRisk(toolName, args) {
+    if (LOW_RISK_TOOLS.includes(toolName))
+        return 'low';
+    const filePath = args?.filePath ?? args?.path ?? '';
+    if (HIGH_RISK_PATTERNS.some(p => p.test(filePath)))
+        return 'high';
+    return 'medium';
+}
+export function getRiskMessage(toolName, riskLevel, args) {
+    const filePath = args?.filePath ?? '';
+    if (riskLevel === 'high')
+        return `Blocked: writing to ${filePath} is not allowed.`;
+    if (riskLevel === 'medium')
+        return `${toolName}${filePath ? ` -> ${filePath}` : ''}`;
+    return '';
+}

package/dist/ui/App.js

@@ -0,0 +1,156 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState, useCallback } from "react";
+import { Box, Text, useApp } from 'ink';
+import TextInput from "ink-text-input";
+import { chat, clearSession, llm, sessionMessages } from '../agent.js';
+import { clearSummary, generateAndSaveSummary } from "../memory.js";
+import { clearProjectMemory, extractAndSaveProjectMemory } from "../projectMemory.js";
+import { useInput } from 'ink';
+import { setConfirmHandler } from "../confirmHandler.js";
+import { explainResponse } from "../agents/explainer.js";
+const COMMANDS = ['/help', '/clear', 'model', '/tools', '/exit', '/reset'];
+export const App = ({ explainMode = false }) => {
+    const { exit } = useApp();
+    const [messages, setMessages] = useState([]);
+    const [input, setInput] = useState('');
+    const [isThinking, setIsThinking] = useState(false);
+    const [toolInfo, setToolInfo] = useState('');
+    const [suggestions, setSuggestions] = useState([]);
+    const [confirmMessage, setConfirmMessage] = useState('');
+    const [confirmInput, setConfirmInput] = useState('');
+    const [confirmResolver, setConfirmResolver] = useState(null);
+    const [streamingContent, setStreamingContent] = useState('');
+    const [inputHistory, setInputHistory] = useState([]);
+    const [historyIndex, setHistoryIndex] = useState(-1);
+    const handleChange = (value) => {
+        setInput(value);
+        if (value.startsWith('/')) {
+            const matches = COMMANDS.filter(c => c.startsWith(value));
+            setSuggestions(value === matches[0] ? [] : matches);
+        }
+        else {
+            setSuggestions([]);
+        }
+    };
+    const handleExit = async () => {
+        await generateAndSaveSummary(sessionMessages, llm);
+        await extractAndSaveProjectMemory(sessionMessages, llm);
+        exit();
+    };
+    useInput((_, key) => {
+        if (confirmMessage)
+            return;
+        if (isThinking)
+            return;
+        if (key.upArrow) {
+            if (inputHistory.length === 0)
+                return;
+            const newIndex = Math.min(historyIndex + 1, inputHistory.length - 1);
+            setHistoryIndex(newIndex);
+            setInput(inputHistory[inputHistory.length - 1 - newIndex] ?? '');
+        }
+        if (key.downArrow) {
+            if (historyIndex <= 0) {
+                setHistoryIndex(-1);
+                setInput('');
+                return;
+            }
+            const newIndex = historyIndex - 1;
+            setHistoryIndex(newIndex);
+            setInput(inputHistory[inputHistory.length - 1 - newIndex] ?? '');
+        }
+        if (key.tab && suggestions.length > 0) {
+            setInput(suggestions[0] ?? '');
+            setSuggestions([]);
+        }
+    });
+    React.useEffect(() => {
+        setConfirmHandler((messages) => {
+            return new Promise((resolve) => {
+                setConfirmMessage(messages);
+                setConfirmResolver(() => resolve);
+            });
+        });
+    }, []);
+    const handleSubmit = useCallback(async (value) => {
+        const cmd = value.trim();
+        setInput('');
+        setSuggestions([]);
+        if (!cmd)
+            return;
+        setInputHistory(prev => prev[prev.length - 1] === cmd ? prev : [...prev, cmd]);
+        setHistoryIndex(-1);
+        if (cmd === '/exit') {
+            await handleExit();
+            return;
+        }
+        if (cmd === '/clear') {
+            clearSession();
+            setMessages([]);
+            return;
+        }
+        if (cmd === '/reset') {
+            clearSession();
+            clearSummary();
+            clearProjectMemory();
+            setMessages([]);
+            return;
+        }
+        if (cmd === '/help') {
+            setMessages(prev => [...prev, {
+                    role: 'assistant',
+                    content: 'Commands: /exit /clear /model /tools /help'
+                }]);
+            return;
+        }
+        if (cmd === '/model') {
+            setMessages(prev => [...prev, { role: 'assistant', content: 'Model: gpr-5-mini' }]);
+            return;
+        }
+        if (cmd === '/tools') {
+            setMessages(prev => [...prev, {
+                    role: 'assistant',
+                    content: 'Tools: listFile readFile searchCode editFile writeFile analyzeProject'
+                }]);
+            return;
+        }
+        setMessages(prev => [...prev, { role: 'user', content: cmd }]);
+        setIsThinking(true);
+        try {
+            const reply = await chat(cmd, (toolName, args) => {
+                const argStr = args ? String(Object.values(args)[0]) : '';
+                setToolInfo(`⚙  ${toolName}${argStr ? ` -> ${argStr}` : ''} `);
+            }, (status) => {
+                setToolInfo(status);
+            }, (token) => {
+                setStreamingContent(prev => prev + token);
+            });
+            setStreamingContent('');
+            setMessages(prev => [...prev, { role: 'assistant', content: reply }]);
+            if (explainMode && reply) {
+                const explanation = await explainResponse(reply);
+                if (explanation) {
+                    setMessages(prev => [...prev, { role: 'explain', content: explanation }]);
+                }
+            }
+        }
+        catch (err) {
+            setMessages(prev => [...prev, {
+                    role: 'error',
+                    content: err?.message ?? 'Something went wrong.'
+                }]);
+        }
+        finally {
+            setIsThinking(false);
+            setToolInfo('');
+        }
+    }, [exit]);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "green", children: "glitool" }), _jsx(Text, { dimColor: true, children: "- AI coding assistant" })] }), messages.map((msg, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [msg.role === 'user' && (_jsxs(Box, { borderStyle: "round", borderColor: "white", paddingX: 1, children: [_jsx(Text, { bold: true, color: "white", children: "You" }), _jsx(Text, { wrap: "wrap", children: msg.content })] })), msg.role === 'assistant' && (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: " Assistant   " }), _jsxs(Text, { color: "red", wrap: "wrap", children: [" ", msg.content, " "] })] })), msg.role === 'error' && (_jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: " Error " }), _jsx(Text, { color: "red", wrap: "wrap", children: msg.content })] })), msg.role === 'explain' && (_jsxs(Box, { borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsx(Text, { bold: true, color: "magenta", children: "\uD83D\uDCA1 Explain " }), _jsx(Text, { wrap: "wrap", children: msg.content })] }))] }, i))), streamingContent !== '' && (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: 'cyan', children: "Assistant" }), _jsxs(Text, { wrap: "wrap", children: [streamingContent, "\u258A"] })] })), isThinking && (_jsx(Box, { marginBottom: 1, padding: 1, children: _jsx(Text, { color: "yellow", children: toolInfo || 'Thinking...' }) })), suggestions.length > 0 && (_jsx(Box, { flexDirection: "column", marginBottom: 1, paddingX: 2, children: suggestions.map(s => (_jsx(Text, { dimColor: true, children: s }, s))) })), confirmMessage !== '' ? (_jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Text, { color: "yellow", children: [" ", confirmMessage, " (y/n): "] }), _jsx(TextInput, { value: confirmInput, onChange: setConfirmInput, onSubmit: (val) => {
+                            const approved = val.toLowerCase() === 'y' || val === '';
+                            confirmResolver?.(approved);
+                            setConfirmMessage('');
+                            setConfirmInput('');
+                            setConfirmResolver(null);
+                        } })] })) :
+                _jsxs(Box, { borderStyle: "round", borderColor: input.length > 200 ? 'yellow' : 'green', paddingX: 1, children: [_jsx(Text, { bold: true, color: "green", children: " You: " }), _jsx(TextInput, { value: input, onChange: handleChange, onSubmit: handleSubmit, placeholder: "Type a message or /help..." }), input.length > 50 && (_jsxs(Text, { dimColor: true, children: [" [", input.length, "]"] }))] })] }));
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+ "name": "glitool",
+  "version": "1.0.0",
+  
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+   "repository": {
+    "type": "git",
+    "url": "https://github.com/deep9038/glitool"
+  },
+  "bin": {
+    "glitool": "./dist/index.js"
+  },
+  "keywords": ["ai", "cli", "coding-assistant", "openai", "terminal"],
+  "author": "Deep Sarkar <deep22sarkar@gmail.com>",
+  "license": "MIT",
+ "description": "AI coding assistant for your terminal",
+ "homepage":"https://github.com/deep9038/glitool",
+  "dependencies": {
+    "@inquirer/prompts": "^8.4.1",
+    "@langchain/core": "^1.1.40",
+    "@langchain/langgraph": "^1.2.9",
+    "@langchain/ollama": "^1.2.6",
+    "@langchain/openai": "^1.4.4",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.4.2",
+    "ink": "^7.0.1",
+    "ink-text-input": "^6.0.0",
+    "ora": "^9.3.0",
+    "react": "^19.2.5"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@types/react": "^19.2.14",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/"
+  ]
+}