@cruxy/cli 0.1.0

package/dist/config/schema.d.ts

@@ -0,0 +1,303 @@
+import { z } from "zod";
+export declare const ProviderSchema: z.ZodEnum<["cruxy", "anthropic", "openai", "custom"]>;
+export type Provider = z.infer<typeof ProviderSchema>;
+export declare const ModelConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<["cruxy", "anthropic", "openai", "custom"]>>;
+    model: z.ZodDefault<z.ZodString>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    provider: "cruxy" | "anthropic" | "openai" | "custom";
+    model: string;
+    maxTokens: number;
+    temperature: number;
+}, {
+    provider?: "cruxy" | "anthropic" | "openai" | "custom" | undefined;
+    model?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+}>;
+/** Cruxy gateway backend settings (no secrets — the API key comes from env). */
+export declare const CruxyBackendConfigSchema: z.ZodObject<{
+    gatewayUrl: z.ZodDefault<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    gatewayUrl: string;
+}, {
+    gatewayUrl?: string | undefined;
+}>;
+export declare const AgentConfigSchema: z.ZodObject<{
+    /** Hard ceiling on agent loop turns. */
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    /** Skip per-action confirmation prompts. */
+    autoApprove: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    maxIterations: number;
+    autoApprove: boolean;
+}, {
+    maxIterations?: number | undefined;
+    autoApprove?: boolean | undefined;
+}>;
+export declare const ToolsConfigSchema: z.ZodObject<{
+    fileEdit: z.ZodDefault<z.ZodBoolean>;
+    shell: z.ZodDefault<z.ZodBoolean>;
+    webSearch: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    fileEdit: boolean;
+    shell: boolean;
+    webSearch: boolean;
+}, {
+    fileEdit?: boolean | undefined;
+    shell?: boolean | undefined;
+    webSearch?: boolean | undefined;
+}>;
+export declare const GitConfigSchema: z.ZodObject<{
+    autoCommit: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    autoCommit: boolean;
+}, {
+    autoCommit?: boolean | undefined;
+}>;
+/** Execution bounds for the `run_command` shell tool (distinct from the
+ * `tools.shell` enable flag above). */
+export declare const ShellConfigSchema: z.ZodObject<{
+    /** Kill the command (and its process tree) after this many ms. */
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    /** Cap on combined stdout+stderr bytes captured; the rest is truncated. */
+    maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    timeoutMs: number;
+    maxOutputBytes: number;
+}, {
+    timeoutMs?: number | undefined;
+    maxOutputBytes?: number | undefined;
+}>;
+/** Context-window management: when to compact the running conversation. */
+export declare const ContextConfigSchema: z.ZodObject<{
+    /** Approximate model context budget, in tokens (heuristic estimate). */
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    /** Compact once the history estimate exceeds this fraction of maxTokens. */
+    compactThreshold: z.ZodDefault<z.ZodNumber>;
+    /** Most-recent messages always kept verbatim (a floor; the cut rounds up to
+     * a clean turn boundary). */
+    keepRecentMessages: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    maxTokens: number;
+    compactThreshold: number;
+    keepRecentMessages: number;
+}, {
+    maxTokens?: number | undefined;
+    compactThreshold?: number | undefined;
+    keepRecentMessages?: number | undefined;
+}>;
+/** How tool-action approval is resolved. */
+export declare const ApprovalConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["prompt", "auto"]>>;
+}, "strict", z.ZodTypeAny, {
+    mode: "auto" | "prompt";
+}, {
+    mode?: "auto" | "prompt" | undefined;
+}>;
+/** MCP server entry — stdio or URL transport (wired up in a later phase). */
+export declare const McpServerSchema: z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    url: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+}, {
+    command?: string | undefined;
+    args?: string[] | undefined;
+    url?: string | undefined;
+}>;
+export declare const CruxyConfigSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodDefault<z.ZodEnum<["cruxy", "anthropic", "openai", "custom"]>>;
+        model: z.ZodDefault<z.ZodString>;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        temperature: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "cruxy" | "anthropic" | "openai" | "custom";
+        model: string;
+        maxTokens: number;
+        temperature: number;
+    }, {
+        provider?: "cruxy" | "anthropic" | "openai" | "custom" | undefined;
+        model?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+    }>>;
+    cruxy: z.ZodDefault<z.ZodObject<{
+        gatewayUrl: z.ZodDefault<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        gatewayUrl: string;
+    }, {
+        gatewayUrl?: string | undefined;
+    }>>;
+    agent: z.ZodDefault<z.ZodObject<{
+        /** Hard ceiling on agent loop turns. */
+        maxIterations: z.ZodDefault<z.ZodNumber>;
+        /** Skip per-action confirmation prompts. */
+        autoApprove: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        maxIterations: number;
+        autoApprove: boolean;
+    }, {
+        maxIterations?: number | undefined;
+        autoApprove?: boolean | undefined;
+    }>>;
+    tools: z.ZodDefault<z.ZodObject<{
+        fileEdit: z.ZodDefault<z.ZodBoolean>;
+        shell: z.ZodDefault<z.ZodBoolean>;
+        webSearch: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        fileEdit: boolean;
+        shell: boolean;
+        webSearch: boolean;
+    }, {
+        fileEdit?: boolean | undefined;
+        shell?: boolean | undefined;
+        webSearch?: boolean | undefined;
+    }>>;
+    git: z.ZodDefault<z.ZodObject<{
+        autoCommit: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        autoCommit: boolean;
+    }, {
+        autoCommit?: boolean | undefined;
+    }>>;
+    shell: z.ZodDefault<z.ZodObject<{
+        /** Kill the command (and its process tree) after this many ms. */
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        /** Cap on combined stdout+stderr bytes captured; the rest is truncated. */
+        maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        timeoutMs: number;
+        maxOutputBytes: number;
+    }, {
+        timeoutMs?: number | undefined;
+        maxOutputBytes?: number | undefined;
+    }>>;
+    context: z.ZodDefault<z.ZodObject<{
+        /** Approximate model context budget, in tokens (heuristic estimate). */
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        /** Compact once the history estimate exceeds this fraction of maxTokens. */
+        compactThreshold: z.ZodDefault<z.ZodNumber>;
+        /** Most-recent messages always kept verbatim (a floor; the cut rounds up to
+         * a clean turn boundary). */
+        keepRecentMessages: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        maxTokens: number;
+        compactThreshold: number;
+        keepRecentMessages: number;
+    }, {
+        maxTokens?: number | undefined;
+        compactThreshold?: number | undefined;
+        keepRecentMessages?: number | undefined;
+    }>>;
+    approval: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<["prompt", "auto"]>>;
+    }, "strict", z.ZodTypeAny, {
+        mode: "auto" | "prompt";
+    }, {
+        mode?: "auto" | "prompt" | undefined;
+    }>>;
+    mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        url: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+    }, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+    }>>>;
+    logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error", "silent"]>>;
+}, "strict", z.ZodTypeAny, {
+    cruxy: {
+        gatewayUrl: string;
+    };
+    model: {
+        provider: "cruxy" | "anthropic" | "openai" | "custom";
+        model: string;
+        maxTokens: number;
+        temperature: number;
+    };
+    shell: {
+        timeoutMs: number;
+        maxOutputBytes: number;
+    };
+    agent: {
+        maxIterations: number;
+        autoApprove: boolean;
+    };
+    tools: {
+        fileEdit: boolean;
+        shell: boolean;
+        webSearch: boolean;
+    };
+    git: {
+        autoCommit: boolean;
+    };
+    context: {
+        maxTokens: number;
+        compactThreshold: number;
+        keepRecentMessages: number;
+    };
+    approval: {
+        mode: "auto" | "prompt";
+    };
+    mcpServers: Record<string, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+    }>;
+    logLevel: "debug" | "info" | "warn" | "error" | "silent";
+}, {
+    cruxy?: {
+        gatewayUrl?: string | undefined;
+    } | undefined;
+    model?: {
+        provider?: "cruxy" | "anthropic" | "openai" | "custom" | undefined;
+        model?: string | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+    } | undefined;
+    shell?: {
+        timeoutMs?: number | undefined;
+        maxOutputBytes?: number | undefined;
+    } | undefined;
+    agent?: {
+        maxIterations?: number | undefined;
+        autoApprove?: boolean | undefined;
+    } | undefined;
+    tools?: {
+        fileEdit?: boolean | undefined;
+        shell?: boolean | undefined;
+        webSearch?: boolean | undefined;
+    } | undefined;
+    git?: {
+        autoCommit?: boolean | undefined;
+    } | undefined;
+    context?: {
+        maxTokens?: number | undefined;
+        compactThreshold?: number | undefined;
+        keepRecentMessages?: number | undefined;
+    } | undefined;
+    approval?: {
+        mode?: "auto" | "prompt" | undefined;
+    } | undefined;
+    mcpServers?: Record<string, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        url?: string | undefined;
+    }> | undefined;
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent" | undefined;
+}>;
+export type CruxyConfig = z.infer<typeof CruxyConfigSchema>;
+/** Fully-populated defaults (every field resolved). */
+export declare function defaultConfig(): CruxyConfig;

package/dist/config/schema.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { LOG_LEVELS } from "../utils/logger.js";
+export const ProviderSchema = z.enum([
+    "cruxy",
+    "anthropic",
+    "openai",
+    "custom",
+]);
+export const ModelConfigSchema = z
+    .object({
+    provider: ProviderSchema.default("cruxy"),
+    // Cruxy tiers: "kavi" | "vaani" | "mira", or "auto" (shimmed to a default
+    // tier client-side until the gateway ships server-side routing).
+    model: z.string().default("auto"),
+    maxTokens: z.number().int().positive().default(8192),
+    temperature: z.number().min(0).max(2).default(0),
+})
+    .strict();
+/** Cruxy gateway backend settings (no secrets — the API key comes from env). */
+export const CruxyBackendConfigSchema = z
+    .object({
+    gatewayUrl: z.string().url().default("https://api.cruxy.in"),
+})
+    .strict();
+export const AgentConfigSchema = z
+    .object({
+    /** Hard ceiling on agent loop turns. */
+    maxIterations: z.number().int().positive().default(25),
+    /** Skip per-action confirmation prompts. */
+    autoApprove: z.boolean().default(false),
+})
+    .strict();
+export const ToolsConfigSchema = z
+    .object({
+    fileEdit: z.boolean().default(true),
+    shell: z.boolean().default(true),
+    webSearch: z.boolean().default(false), // C.17
+})
+    .strict();
+export const GitConfigSchema = z
+    .object({
+    autoCommit: z.boolean().default(false),
+})
+    .strict();
+/** Execution bounds for the `run_command` shell tool (distinct from the
+ * `tools.shell` enable flag above). */
+export const ShellConfigSchema = z
+    .object({
+    /** Kill the command (and its process tree) after this many ms. */
+    timeoutMs: z.number().int().positive().default(120000),
+    /** Cap on combined stdout+stderr bytes captured; the rest is truncated. */
+    maxOutputBytes: z.number().int().positive().default(102400),
+})
+    .strict();
+/** Context-window management: when to compact the running conversation. */
+export const ContextConfigSchema = z
+    .object({
+    /** Approximate model context budget, in tokens (heuristic estimate). */
+    maxTokens: z.number().int().positive().default(100000),
+    /** Compact once the history estimate exceeds this fraction of maxTokens. */
+    compactThreshold: z.number().min(0).max(1).default(0.75),
+    /** Most-recent messages always kept verbatim (a floor; the cut rounds up to
+     * a clean turn boundary). */
+    keepRecentMessages: z.number().int().positive().default(6),
+})
+    .strict();
+/** How tool-action approval is resolved. */
+export const ApprovalConfigSchema = z
+    .object({
+    // "prompt": ask interactively (deny when non-interactive). "auto": approve
+    // every action unattended (CI / explicit opt-in).
+    mode: z.enum(["prompt", "auto"]).default("prompt"),
+})
+    .strict();
+/** MCP server entry — stdio or URL transport (wired up in a later phase). */
+export const McpServerSchema = z
+    .object({
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    url: z.string().url().optional(),
+})
+    .strict();
+export const CruxyConfigSchema = z
+    .object({
+    model: ModelConfigSchema.default({}),
+    cruxy: CruxyBackendConfigSchema.default({}),
+    agent: AgentConfigSchema.default({}),
+    tools: ToolsConfigSchema.default({}),
+    git: GitConfigSchema.default({}),
+    shell: ShellConfigSchema.default({}),
+    context: ContextConfigSchema.default({}),
+    approval: ApprovalConfigSchema.default({}),
+    mcpServers: z.record(z.string(), McpServerSchema).default({}),
+    logLevel: z.enum(LOG_LEVELS).default("info"),
+})
+    .strict();
+/** Fully-populated defaults (every field resolved). */
+export function defaultConfig() {
+    return CruxyConfigSchema.parse({});
+}

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const APP_NAME = "cruxy";
+export declare const APP_PACKAGE: string;
+export declare const APP_VERSION: string;
+export declare const APP_DESCRIPTION: string;
+/** Directory/file names cruxy looks for. */
+export declare const GLOBAL_DIR_NAME = ".cruxy";
+export declare const CONFIG_FILE_NAME = "config.json";
+/** Project-level config filenames, checked in order. */
+export declare const PROJECT_CONFIG_FILENAMES: string[];
+/** Project-instruction filenames, checked in order (first match wins). */
+export declare const PROJECT_INSTRUCTION_FILENAMES: string[];

package/dist/constants.js

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Both dist/constants.js and src/constants.ts sit one level below this
+// package's root, so the package-local package.json is always at "../".
+// (Do NOT walk further up — that would resolve to the monorepo root package.json.)
+function loadPkg() {
+    const pkgPath = join(__dirname, "..", "package.json");
+    try {
+        return JSON.parse(readFileSync(pkgPath, "utf8"));
+    }
+    catch {
+        return { name: "@cruxy/cli", version: "0.0.0" };
+    }
+}
+const pkg = loadPkg();
+export const APP_NAME = "cruxy";
+export const APP_PACKAGE = pkg.name;
+export const APP_VERSION = pkg.version;
+export const APP_DESCRIPTION = pkg.description ?? "an agentic coding CLI";
+/** Directory/file names cruxy looks for. */
+export const GLOBAL_DIR_NAME = ".cruxy";
+export const CONFIG_FILE_NAME = "config.json";
+/** Project-level config filenames, checked in order. */
+export const PROJECT_CONFIG_FILENAMES = [
+    "cruxy.config.json",
+    ".cruxy/config.json",
+];
+/** Project-instruction filenames, checked in order (first match wins). */
+export const PROJECT_INSTRUCTION_FILENAMES = ["CRUXY.md", "AGENTS.md"];

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import pc from "picocolors";
+import { buildProgram } from "./cli/program.js";
+import { logger } from "./utils/logger.js";
+async function main() {
+    const program = buildProgram();
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(pc.red(message));
+    process.exit(1);
+});

package/dist/tools/file/apply-patch.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import type { Tool } from "../types.js";
+declare const parameters: z.ZodObject<{
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"update">;
+        path: z.ZodString;
+        hunks: z.ZodArray<z.ZodObject<{
+            oldStr: z.ZodString;
+            newStr: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            oldStr: string;
+            newStr: string;
+        }, {
+            oldStr: string;
+            newStr: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: "update";
+        hunks: {
+            oldStr: string;
+            newStr: string;
+        }[];
+    }, {
+        path: string;
+        type: "update";
+        hunks: {
+            oldStr: string;
+            newStr: string;
+        }[];
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"create">;
+        path: z.ZodString;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: "create";
+        content: string;
+    }, {
+        path: string;
+        type: "create";
+        content: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"delete">;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: "delete";
+    }, {
+        path: string;
+        type: "delete";
+    }>]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    operations: ({
+        path: string;
+        type: "update";
+        hunks: {
+            oldStr: string;
+            newStr: string;
+        }[];
+    } | {
+        path: string;
+        type: "create";
+        content: string;
+    } | {
+        path: string;
+        type: "delete";
+    })[];
+}, {
+    operations: ({
+        path: string;
+        type: "update";
+        hunks: {
+            oldStr: string;
+            newStr: string;
+        }[];
+    } | {
+        path: string;
+        type: "create";
+        content: string;
+    } | {
+        path: string;
+        type: "delete";
+    })[];
+}>;
+/**
+ * Apply a set of file edits across one or more files in a single, atomic,
+ * reviewed operation. The entire patch is validated up front — every path
+ * resolved inside the project, every `update` hunk confirmed to match exactly
+ * once, every `create` confirmed absent and `delete` confirmed present — and if
+ * anything fails, nothing is written. A single approval covers the whole patch.
+ */
+export declare const applyPatchTool: Tool<typeof parameters>;
+export {};