@pruddiman/hem 0.0.1-beta-1ec07ab → 0.0.1-beta-95d42fc

package/dist/providers/copilot.d.ts

@@ -27,10 +27,21 @@ interface PermissionRequest {
     command?: string;
     [key: string]: unknown;
 }
-/** Minimal permission result returned to the SDK. */
-interface PermissionResult {
-    kind: "approved" | "denied-by-rules";
-}
+/**
+ * Minimal permission result returned to the SDK.
+ *
+ * Mirrors the subset of `PermissionDecision` from `@github/copilot-sdk`
+ * we actually emit: a one-shot approval or a reject. The SDK changed
+ * these literals in 0.3.0 (`approved` → `approve-once`,
+ * `denied-by-rules` → `reject`); anything else round-trips as
+ * `no-result`, which silently blocks tool calls.
+ */
+type PermissionResult = {
+    kind: "approve-once";
+} | {
+    kind: "reject";
+    feedback?: string;
+};
 /**
  * Minimal interface for a Copilot session, matching the subset of
  * `CopilotSession` from `@github/copilot-sdk` used by the provider.

package/dist/providers/copilot.js

@@ -318,30 +318,30 @@ export class CopilotProvider {
             const agent = agentContext.name;
             // No agent context yet — default to approve-all.
             if (!agent) {
-                return { kind: "approved" };
+                return { kind: "approve-once" };
             }
             switch (request.kind) {
                 case "write":
                     return agentAllowsEdit(agent)
-                        ? { kind: "approved" }
-                        : { kind: "denied-by-rules" };
+                        ? { kind: "approve-once" }
+                        : { kind: "reject" };
                 case "shell": {
                     const cmd = request.command ?? "";
                     return agentAllowsShell(agent, cmd)
-                        ? { kind: "approved" }
-                        : { kind: "denied-by-rules" };
+                        ? { kind: "approve-once" }
+                        : { kind: "reject" };
                 }
                 case "url":
                     return agentAllowsWebfetch(agent)
-                        ? { kind: "approved" }
-                        : { kind: "denied-by-rules" };
+                        ? { kind: "approve-once" }
+                        : { kind: "reject" };
                 case "mcp":
                 case "read":
                 case "custom-tool":
                     // Always allow MCP (broadcast), read-only access, and custom tools.
-                    return { kind: "approved" };
+                    return { kind: "approve-once" };
                 default:
-                    return { kind: "denied-by-rules" };
+                    return { kind: "reject" };
             }
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pruddiman/hem",
-  "version": "0.0.1-beta-1ec07ab",
+  "version": "0.0.1-beta-95d42fc",
   "type": "module",
   "bin": {
     "hem": "./dist/index.js"

package/dist/agents/grouping-agent.d.ts

@@ -1,167 +0,0 @@
-/**
- * LLM-assisted file grouping agent for Hem.
- *
- * Uses an OpenCode session to analyze source files and produce semantically
- * meaningful documentation groups. Falls back gracefully — returns `null`
- * on any failure so the caller can use heuristic grouping instead.
- *
- * The agent:
- *   1. Reads file contents and extracts import dependencies (programmatic).
- *   2. Builds a structured prompt with file summaries + dependency graph.
- *   3. Sends the prompt to an OpenCode session.
- *   4. Parses the strongly-typed JSON response.
- *   5. Maps results to `FileGroup[]` with hallucination guards.
- */
-import type { Provider } from "../providers/types.js";
-import type { FileInfo, FileGroup } from "../types.js";
-import { BaseAgent } from "./base-agent.js";
-/** Raw LLM output schema — what the JSON response must match. */
-export interface GroupingResult {
-    id: string;
-    label: string;
-    type: "vertical" | "horizontal";
-    files: string[];
-    rationale: string;
-}
-/** File name for the on-disk grouping result cache. */
-export declare const GROUPING_CACHE_FILE = "grouping-cache.json";
-/**
- * File count threshold: when there are more files than this, use chunked
- * grouping (split into batches → parallel LLM sessions → merge results).
- * Below this threshold, the original single-prompt approach is used.
- */
-export declare const GROUPING_CHUNK_THRESHOLD = 200;
-/**
- * Target number of files per batch when chunking. Batches are sized to
- * stay well within LLM context limits (~100 files × 40 lines each ≈ 4000
- * lines of context, comfortably under typical 128K-200K token windows).
- */
-export declare const FILES_PER_CHUNK = 100;
-/**
- * An agent that uses an LLM to group source files into cohesive
- * documentation topics.
- */
-export declare class GroupingAgent extends BaseAgent {
-    private projectName;
-    constructor(provider: Provider, projectName: string);
-    /**
-     * Run the full grouping pipeline: read → analyze → prompt → parse → map.
-     *
-     * @param files    - Discovered source files to group.
-     * @param verbose  - Optional logging callback (writes to stderr).
-     * @param cacheDir - Optional directory for the grouping result cache
-     *                   (typically the `.hem` directory in the project root).
-     *                   When provided, a cache hit skips the LLM call entirely.
-     * @returns `FileGroup[]` on success, `null` on any failure.
-     */
-    run(files: FileInfo[], verbose?: (msg: string) => void, cacheDir?: string): Promise<FileGroup[] | null>;
-    /**
-     * Chunked grouping for large file sets.
-     *
-     * Splits files into batches that fit within context limits, runs
-     * multiple grouping sessions in parallel, and merges the results.
-     * Returns raw {@link GroupingResult}[] (before `mapToFileGroups`).
-     */
-    private runChunkedRaw;
-    /**
-     * Read file contents for all files. Files that fail to read get an
-     * error placeholder.
-     */
-    static readFiles(files: FileInfo[]): Promise<Array<{
-        path: string;
-        content: string;
-        size: number;
-    }>>;
-    /**
-     * Extract import dependencies from file contents via regex.
-     *
-     * Handles:
-     *   - `import ... from "./foo.js"`
-     *   - `import ... from "../bar/baz.js"`
-     *   - `import("./dynamic.js")`
-     *   - `require("./cjs.js")`
-     *
-     * Only tracks local (relative) imports — ignores node_modules.
-     *
-     * @returns Map from file path → array of imported file paths.
-     */
-    static analyzeImports(fileContents: Array<{
-        path: string;
-        content: string;
-    }>): Map<string, string[]>;
-    /**
-     * Build the grouping prompt from file summaries and import graph.
-     *
-     * Includes the first 40 lines of each file plus the dependency graph
-     * so the LLM can make informed grouping decisions.
-     */
-    static buildPrompt(projectName: string, fileContents: Array<{
-        path: string;
-        content: string;
-        size: number;
-    }>, imports: Map<string, string[]>): string;
-    /**
-     * Extract and validate JSON from the LLM response.
-     *
-     * Tries to find a fenced ```json block first, then falls back to
-     * parsing the entire response as JSON.
-     *
-     * @returns Validated array of `GroupingResult`, or `null` if invalid.
-     */
-    static parseResponse(response: string): GroupingResult[] | null;
-    /**
-     * Map validated LLM results to `FileGroup[]`.
-     *
-     * Resolves file paths against the known file set, skipping any
-     * paths the LLM hallucinated. Computes `directory` via
-     * `commonDirectory()` from `grouping.ts`.
-     */
-    static mapToFileGroups(results: GroupingResult[], filesByPath: Map<string, FileInfo>): FileGroup[];
-    /**
-     * Split file contents into batches of approximately `chunkSize` files.
-     *
-     * Files are split sequentially — no shuffling — so files that are
-     * close in the directory listing stay together, improving the LLM's
-     * ability to detect intra-chunk relationships.
-     */
-    static splitIntoChunks(fileContents: Array<{
-        path: string;
-        content: string;
-        size: number;
-    }>, chunkSize: number): Array<Array<{
-        path: string;
-        content: string;
-        size: number;
-    }>>;
-    /**
-     * Merge grouping results from multiple chunks.
-     *
-     * Groups from different chunks may overlap — e.g., two chunks may each
-     * produce an "Authentication" group containing different files. This
-     * method merges groups with the same `id` (after kebab-case normalization)
-     * by combining their file lists and deduplicating.
-     *
-     * When groups share the same normalized ID:
-     *   - File lists are unioned (deduplicated).
-     *   - The label and type from the first occurrence are kept.
-     *   - Rationales are concatenated.
-     *
-     * @param results - All `GroupingResult[]` from every chunk (flattened).
-     * @returns Merged array of `GroupingResult`.
-     */
-    static mergeGroupingResults(results: GroupingResult[]): GroupingResult[];
-    /**
-     * Compute a stable hash of the file list for cache invalidation.
-     * Uses path + size so renames and size changes invalidate the cache.
-     */
-    static computeFilesHash(files: FileInfo[]): string;
-    /**
-     * Attempt to load a valid cache entry from `cacheDir`.
-     * Returns `null` on miss, parse error, or hash mismatch.
-     */
-    static loadGroupingCache(cacheDir: string, filesHash: string): Promise<GroupingResult[] | null>;
-    /**
-     * Write grouping results to the cache file (best-effort, never throws).
-     */
-    static saveGroupingCache(cacheDir: string, filesHash: string, results: GroupingResult[]): Promise<void>;
-}