harnessly 1.0.0

package/build/tools.js

@@ -0,0 +1,142 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { checkPath, checkCommand, logToolCall, } from './harness';
+const MAX_OUTPUT_LENGTH = 10000;
+function truncate(text, limit = MAX_OUTPUT_LENGTH) {
+    if (text.length <= limit)
+        return text;
+    const half = Math.floor(limit / 2);
+    return text.slice(0, half) + `\n\n... [truncated ${text.length - limit} chars] ...\n\n` + text.slice(-half);
+}
+export function createTools() {
+    function timedExecute(toolName, input, fn) {
+        const start = Date.now();
+        const result = fn();
+        const durationMs = Date.now() - start;
+        logToolCall({
+            timestamp: new Date().toISOString(),
+            tool: toolName,
+            input,
+            result,
+            durationMs,
+        });
+        return result;
+    }
+    return {
+        readFile: tool({
+            description: 'Read the contents of a file at the given path',
+            inputSchema: z.object({
+                filePath: z.string().describe('Path to the file to read'),
+            }),
+            execute: async ({ filePath }) => {
+                const pathCheck = checkPath(filePath);
+                if (!pathCheck.allowed)
+                    return pathCheck.reason;
+                return timedExecute('readFile', { filePath }, () => {
+                    try {
+                        const absolutePath = path.resolve(filePath);
+                        const content = fs.readFileSync(absolutePath, 'utf-8');
+                        return truncate(content);
+                    }
+                    catch (e) {
+                        return `Error reading file: ${e.message}`;
+                    }
+                });
+            },
+        }),
+        writeFile: tool({
+            description: 'Write content to a file. Creates the file and directories if they do not exist.',
+            inputSchema: z.object({
+                filePath: z.string().describe('Path to the file to write'),
+                content: z.string().describe('Content to write to the file'),
+            }),
+            execute: async ({ filePath, content }) => {
+                const pathCheck = checkPath(filePath);
+                if (!pathCheck.allowed)
+                    return pathCheck.reason;
+                return timedExecute('writeFile', { filePath, content }, () => {
+                    try {
+                        const absolutePath = path.resolve(filePath);
+                        fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+                        fs.writeFileSync(absolutePath, content);
+                        return `File written successfully: ${absolutePath}`;
+                    }
+                    catch (e) {
+                        return `Error writing file: ${e.message}`;
+                    }
+                });
+            },
+        }),
+        listDirectory: tool({
+            description: 'List files and directories at the given path',
+            inputSchema: z.object({
+                dirPath: z.string().describe('Path to the directory to list').default('.'),
+            }),
+            execute: async ({ dirPath }) => {
+                const pathCheck = checkPath(dirPath);
+                if (!pathCheck.allowed)
+                    return pathCheck.reason;
+                return timedExecute('listDirectory', { dirPath }, () => {
+                    try {
+                        const absolutePath = path.resolve(dirPath);
+                        const entries = fs.readdirSync(absolutePath, { withFileTypes: true });
+                        return entries.map(e => `${e.isDirectory() ? '📁' : '📄'} ${e.name}`).join('\n');
+                    }
+                    catch (e) {
+                        return `Error listing directory: ${e.message}`;
+                    }
+                });
+            },
+        }),
+        runCommand: tool({
+            description: 'Run a shell command and return its output. Use this for git, npm, or any CLI command.',
+            inputSchema: z.object({
+                command: z.string().describe('The shell command to execute'),
+            }),
+            execute: async ({ command }) => {
+                const cmdCheck = checkCommand(command);
+                if (!cmdCheck.allowed)
+                    return cmdCheck.reason;
+                return timedExecute('runCommand', { command }, () => {
+                    try {
+                        const output = execSync(command, {
+                            encoding: 'utf-8',
+                            timeout: 30000,
+                            cwd: process.cwd(),
+                        });
+                        return truncate(output || '(no output)');
+                    }
+                    catch (e) {
+                        return `Command failed: ${e.message}\n${e.stdout || ''}${e.stderr || ''}`;
+                    }
+                });
+            },
+        }),
+        searchFiles: tool({
+            description: 'Search for a text pattern across files in a directory (like grep)',
+            inputSchema: z.object({
+                pattern: z.string().describe('Text or regex pattern to search for'),
+                dirPath: z.string().describe('Directory to search in').default('.'),
+            }),
+            execute: async ({ pattern, dirPath }) => {
+                const pathCheck = checkPath(dirPath);
+                if (!pathCheck.allowed)
+                    return pathCheck.reason;
+                return timedExecute('searchFiles', { pattern, dirPath }, () => {
+                    try {
+                        const output = execSync(`findstr /s /n /i "${pattern}" "${path.resolve(dirPath)}\\*"`, { encoding: 'utf-8', timeout: 15000 });
+                        return truncate(output || 'No matches found.');
+                    }
+                    catch (e) {
+                        if (e.status === 1)
+                            return 'No matches found.';
+                        return `Search error: ${e.message}`;
+                    }
+                });
+            },
+        }),
+    };
+}

package/build/ui.d.ts

@@ -0,0 +1,12 @@
+declare const PROVIDERS: readonly ['OpenAI', 'Anthropic', 'Azure', 'Custom'];
+type Provider = (typeof PROVIDERS)[number];
+export interface ProviderConfig {
+    provider: Provider;
+    apiKey: string;
+    model: string;
+    resourceName?: string;
+    baseURL?: string;
+}
+export declare function Welcome(): void;
+export declare function SelectProvider(): Promise<ProviderConfig>;
+export {};

package/build/ui.js

@@ -0,0 +1,156 @@
+// import chalk from 'chalk';
+// import { select, text, isCancel, intro } from '@clack/prompts';
+// const providers = [
+//     { value: 'OpenAI', label: 'OpenAI' },
+//     { value: 'Anthropic', label: 'Anthropic' },
+//     { value: 'Google', label: 'Google' },
+//     { value: 'Azure', label: 'Azure' },
+//     { value: 'Custom', label: 'Custom' },
+// ];
+// export interface ProviderConfig {
+//     provider: string;
+//     apiKey: string;
+//     model?: string;
+//     resourceName?: string;
+//     baseURL?: string;
+// }
+// export function Welcome() {
+//     console.log('');
+//     console.log(chalk.cyan.bold('  ╔══════════════════════════════════╗'));
+//     console.log(chalk.cyan.bold('  ║') + chalk.white.bold('           D E V R A              ') + chalk.cyan.bold('║'));
+//     console.log(chalk.cyan.bold('  ╚══════════════════════════════════╝'));
+//     console.log(chalk.gray('    Your AI-powered coding agent'));
+//     console.log(chalk.dim('    Type "exit" to quit | Ctrl+C to cancel'));
+//     console.log('');
+// }
+// function prompt<T>(result: T | symbol): T {
+//     if (isCancel(result)) {
+//         console.log(chalk.dim('\nSetup cancelled.\n'));
+//         process.exit(0);
+//     }
+//     return result as T;
+// }
+// export async function SelectProvider(): Promise<ProviderConfig> {
+//     intro(chalk.bold('Setup'));
+//     const provider = prompt(await select({
+//         message: 'Select your AI provider',
+//         options: providers,
+//     }));
+//     const apiKey = prompt(await text({
+//         message: `Enter your ${provider} API Key`,
+//         placeholder: 'sk-...',
+//         validate: (val) => (val || '').length < 4 ? 'API key is too short' : undefined,
+//     }));
+//     const config: ProviderConfig = { provider, apiKey };
+//     if (provider === 'Azure') {
+//         config.resourceName = prompt(await text({
+//             message: 'Enter Azure Resource Name',
+//             placeholder: 'my-resource',
+//         }));
+//     }
+//     if (provider === 'Custom') {
+//         config.baseURL = prompt(await text({
+//             message: 'Enter base URL',
+//             placeholder: 'http://localhost:11434/v1',
+//         }));
+//     }
+//     const defaultModel = getDefaultModel(provider);
+//     const model = prompt(await text({
+//         message: 'Model name',
+//         placeholder: defaultModel,
+//         defaultValue: defaultModel,
+//     }));
+//     config.model = model || defaultModel;
+//     console.log('');
+//     console.log(chalk.green('  ✓ ') + chalk.bold('Ready!') + chalk.dim(` (${provider} / ${config.model})`));
+//     console.log('');
+//     console.log(chalk.dim('  Configurations ') + process.cwd());
+//     console.log(chalk.dim(''))
+//     console.log('');
+//     return config;
+// }
+// function getDefaultModel(provider: string): string {
+//     const defaults: Record<string, string> = {
+//         OpenAI: 'gpt-4o',
+//         Anthropic: 'claude-sonnet-4-20250514',
+//         Google: 'gemini-2.0-flash',
+//         Azure: 'gpt-4o',
+//         Custom: 'custom-model',
+//     };
+//     return defaults[provider] || 'gpt-4o';
+// }
+import chalk from 'chalk';
+import { select, text, password, note, isCancel, intro, outro, cancel } from '@clack/prompts';
+const PROVIDERS = ['OpenAI', 'Anthropic', 'Azure', 'Custom'];
+const providerOptions = PROVIDERS.map((p) => ({ value: p, label: p }));
+const DEFAULT_MODELS = {
+    OpenAI: 'gpt-4o',
+    Anthropic: 'claude-sonnet-4-5',
+    Azure: 'gpt-4o',
+    Custom: 'custom-model',
+};
+export function Welcome() {
+    console.log('');
+    console.log(chalk.cyan.bold('  ╔══════════════════════════════════╗'));
+    console.log(chalk.cyan.bold('  ║') + chalk.white.bold('        H A R N E S S L Y         ') + chalk.cyan.bold('║'));
+    console.log(chalk.cyan.bold('  ╚══════════════════════════════════╝'));
+    console.log(chalk.gray('    Your harnessed AI coding agent'));
+    console.log(chalk.dim('    Type "exit" to quit | Ctrl+C to cancel'));
+    console.log('');
+}
+/** Unwraps a clack prompt result, exiting cleanly on Ctrl+C / cancel. */
+function unwrap(result) {
+    if (isCancel(result)) {
+        cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    return result;
+}
+function isValidUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function SelectProvider() {
+    intro(chalk.bold('Setup'));
+    const provider = unwrap(await select({
+        message: 'Select your AI provider',
+        options: providerOptions,
+    }));
+    // password() masks input as it's typed — apiKey should never use text().
+    const apiKey = unwrap(await password({
+        message: `Enter your ${provider} API Key`,
+        validate: (val) => ((val || '').trim().length < 4 ? 'API key is too short' : undefined),
+    }));
+    const config = { provider, apiKey, model: DEFAULT_MODELS[provider] };
+    if (provider === 'Azure') {
+        config.resourceName = unwrap(await text({
+            message: 'Enter Azure Resource Name',
+            placeholder: 'my-resource',
+            validate: (val) => ((val || '').trim().length === 0 ? 'Resource name is required' : undefined),
+        }));
+    }
+    if (provider === 'Custom') {
+        config.baseURL = unwrap(await text({
+            message: 'Enter base URL',
+            placeholder: 'http://localhost:11434/v1',
+            validate: (val) => (!isValidUrl(val || '') ? 'Enter a valid URL' : undefined),
+        }));
+    }
+    const defaultModel = DEFAULT_MODELS[provider];
+    const model = unwrap(await text({
+        message: 'Model name',
+        placeholder: defaultModel,
+        defaultValue: defaultModel,
+    }));
+    config.model = model;
+    note(`${chalk.dim('Provider')}  ${config.provider}\n` +
+        `${chalk.dim('Model')}     ${config.model}\n` +
+        `${chalk.dim('Config')}    ${process.cwd()}`, chalk.green('Ready'));
+    outro(chalk.dim('Starting session...'));
+    return config;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "harnessly",
+  "version": "1.0.0",
+  "description": "A harnessed AI coding agent CLI with guardrails, approval flow, observability, and error recovery",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "bin": {
+    "harnessly": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VomeshAtukuri/coding-agent.git"
+  },
+  "homepage": "https://github.com/VomeshAtukuri/coding-agent#readme",
+  "bugs": {
+    "url": "https://github.com/VomeshAtukuri/coding-agent/issues"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node build/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "coding",
+    "agent",
+    "cli",
+    "ai",
+    "harness",
+    "guardrails",
+    "approval",
+    "observability",
+    "llm",
+    "terminal"
+  ],
+  "author": "Vomesh",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^4.0.42",
+    "@ai-sdk/azure": "^4.0.42",
+    "@ai-sdk/openai": "^4.0.41",
+    "@clack/prompts": "^1.7.0",
+    "ai": "^7.0.65",
+    "cac": "^7.0.0",
+    "chalk": "^6.0.0",
+    "ora": "^9.4.1",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "nodemon": "^3.1.14",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  }
+}