indusagi 0.13.7 → 0.13.8

package/dist/types/facade/bot/actions/crew/worktree.d.ts

@@ -0,0 +1,39 @@
+export type WorktreeCleanupResult = {
+    removedWorktrees: string[];
+    removedBranches: string[];
+    warnings: string[];
+};
+export type WorktreeResult = {
+    cwd: string;
+    warnings: string[];
+    mode: "worktree" | "shared";
+};
+/**
+ * Ensure a per-teammate git worktree exists, returning the cwd to use for that teammate.
+ *
+ * Behavior:
+ * - If not in a git repo, falls back to shared cwd with a warning.
+ * - If git repo is dirty, still creates a worktree but warns that uncommitted changes are not included.
+ */
+export declare function ensureWorktreeCwd(opts: {
+    leaderCwd: string;
+    teamDir: string;
+    teamId: string;
+    agentName: string;
+}): Promise<WorktreeResult>;
+/**
+ * Remove all git worktrees under `<teamDir>/worktrees/` and their associated branches.
+ *
+ * Steps for each worktree:
+ * 1. `git worktree remove --force <path>` (removes the worktree checkout)
+ * 2. `git branch -D <branch>` (removes the local branch)
+ * 3. Falls back to filesystem removal if git commands fail
+ *
+ * Also runs `git worktree prune` to clean up stale worktree bookkeeping.
+ */
+export declare function cleanupWorktrees(opts: {
+    teamDir: string;
+    teamId: string;
+    /** A directory known to be in the git repo (e.g. leaderCwd). */
+    repoCwd?: string;
+}): Promise<WorktreeCleanupResult>;

package/dist/types/facade/bot/actions/edit-diff.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Support code for the edit tool. Four concerns live here: sniffing whether a
+ * file uses LF or CRLF endings, stripping a leading byte-order mark, matching a
+ * target span tolerantly (exact first, then a normalized fallback), and emitting
+ * a line-oriented diff. The diff is computed with an LCS routine written in this
+ * file, so the module pulls in no third-party diffing dependency.
+ */
+export declare function detectLineEnding(content: string): "\r\n" | "\n";
+export declare function normalizeToLF(text: string): string;
+export declare function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string;
+/**
+ * Reduce text to a single canonical shape so inputs that differ only cosmetically
+ * compare as identical. Transformations run one after another: drop trailing
+ * blanks on every line, fold curly quotes to ASCII quotes, fold the dash family to
+ * "-", and fold any non-ASCII blank to an ordinary space.
+ */
+export declare function normalizeForFuzzyMatch(text: string): string;
+export interface FuzzyMatchResult {
+    /** Whether the lookup turned up the requested text at all. */
+    found: boolean;
+    /** Position at which the match starts, relative to contentForReplacement. */
+    index: number;
+    /** Length, in characters, of the matched region. */
+    matchLength: number;
+    /** Set when the hit only landed after normalization rather than as a literal match. */
+    usedFuzzyMatch: boolean;
+    /**
+     * The precise string the caller is meant to edit into. For a literal hit this
+     * equals the original input; for a normalized hit it is the canonicalized
+     * form, because that is what index and matchLength are measured against.
+     */
+    contentForReplacement: string;
+}
+/**
+ * Find oldText within content, trying a literal match first and only resorting
+ * to a normalized comparison when that misses. For a normalized hit,
+ * contentForReplacement carries the canonicalized text (trailing spaces gone,
+ * quotes/dashes/spaces mapped), and that is what index and matchLength index into.
+ */
+export declare function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult;
+/** Spot a leading UTF-8 byte-order mark and split it off from the rest of the text. */
+export declare function stripBom(content: string): {
+    bom: string;
+    text: string;
+};
+/**
+ * Build a line-by-line diff backed solely by the in-house LCS routine (no diff
+ * library). Returns the formatted diff alongside the 1-based line number of the
+ * earliest change in the updated text.
+ */
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): {
+    diff: string;
+    firstChangedLine: number | undefined;
+};
+export interface EditDiffResult {
+    diff: string;
+    firstChangedLine: number | undefined;
+}
+export interface EditDiffError {
+    error: string;
+}
+/**
+ * Determine what an edit would alter without writing anything to disk.
+ * Backs the preview the UI renders before the edit tool actually runs.
+ */
+export declare function computeEditDiff(path: string, oldText: string, newText: string, cwd: string): Promise<EditDiffResult | EditDiffError>;

package/dist/types/facade/bot/actions/edit-utils.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Precision helpers for the edit tool. None of these change the default
+ * behaviour of an edit — they kick in only on the recovery / preservation
+ * paths:
+ *
+ *  - {@link preserveQuoteStyle} re-applies a file's curly-quote typography to
+ *    replacement text when the match was found only after folding curly quotes
+ *    to straight ones, so an edit doesn't quietly downgrade `"` → `“`.
+ *  - {@link desanitizeMatchString} repairs the handful of tag tokens an API
+ *    transport may mangle (`<o>` → `<output>`, `\n\nH:` → `\n\nHuman:`, …) so a
+ *    snippet that lost its angle-bracket words can still be located. It is only
+ *    ever used as a *fallback* (try the literal text first) because several of
+ *    the rules collide with ordinary code.
+ *  - {@link findSimilarFile} and {@link suggestPathUnderCwd} build the "did you
+ *    mean …?" hint when a path doesn't resolve.
+ *  - {@link replaceAllLiteral} swaps every non-overlapping literal occurrence of
+ *    a needle, used for the `replaceAll` edit mode.
+ *
+ * Everything here is pure / node-fs only and carries no dependency on the rest
+ * of the edit pipeline.
+ */
+export declare const LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+export declare const RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+export declare const LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+export declare const RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+/**
+ * When `oldText` only matched the file after curly quotes were folded to
+ * straight quotes, re-apply the file's curly typography to `newString` so the
+ * edit preserves the original quote style. A no-op when `oldString` already
+ * equals the matched text (no folding happened) or when the matched text holds
+ * no curly quotes.
+ *
+ * @param oldString The text the model supplied (straight quotes).
+ * @param actualOldString The text actually located in the file (may be curly).
+ * @param newString The replacement text the model supplied (straight quotes).
+ */
+export declare function preserveQuoteStyle(oldString: string, actualOldString: string, newString: string): string;
+/**
+ * Tag tokens an API transport sometimes mangles, mapped back to their full
+ * form. Several of these (`<n>`, `\n\nH:`) appear in ordinary source, so the
+ * table must only ever be consulted as a *fallback* after a literal match
+ * misses — never preemptively.
+ */
+export declare const DESANITIZATIONS: Record<string, string>;
+/**
+ * Expand any mangled tag tokens in `matchString`, reporting which replacements
+ * fired so the caller can mirror them onto the replacement text.
+ */
+export declare function desanitizeMatchString(matchString: string): {
+    result: string;
+    appliedReplacements: Array<{
+        from: string;
+        to: string;
+    }>;
+};
+/**
+ * Look in `filePath`'s directory for a file that shares its base name but has a
+ * different extension (e.g. `foo.ts` when `foo.js` was requested). Returns the
+ * sibling's bare filename, or `undefined` when there is no such neighbour.
+ */
+export declare function findSimilarFile(filePath: string): string | undefined;
+/**
+ * Marker embedded in file-not-found messages that carry a cwd note. A UI
+ * renderer can key off this to collapse the long message into a short
+ * "File not found" badge.
+ */
+export declare const FILE_NOT_FOUND_CWD_NOTE = "Note: your current working directory is";
+/**
+ * Suggest a corrected path under `cwd` when an absolute path doesn't resolve.
+ * Catches the "dropped repo folder" pattern: the model builds an absolute path
+ * that sits beside the repo rather than inside it.
+ *
+ *   cwd           = /Users/x/src/currentRepo
+ *   requestedPath = /Users/x/src/foobar           (missing)
+ *   returns         /Users/x/src/currentRepo/foobar (when it exists)
+ *
+ * @param requestedPath The absolute path that was not found.
+ * @param cwd The working directory to re-root the suggestion under.
+ */
+export declare function suggestPathUnderCwd(requestedPath: string, cwd: string): Promise<string | undefined>;
+/**
+ * Replace every non-overlapping literal occurrence of `needle` in `haystack`
+ * with `value`. Ported verbatim from the kernel `edit` capability so the
+ * `replaceAll` edit mode shares one definition of "replace all".
+ */
+export declare function replaceAllLiteral(haystack: string, needle: string, value: string): string;

package/dist/types/facade/bot/actions/edit.d.ts

@@ -0,0 +1,59 @@
+import type { AgentTool } from "../types.js";
+import { fuzzyFindText } from "./edit-diff.js";
+import { type CheckpointHandle } from "./checkpoint.js";
+import { type ReadStateHandle } from "./read-state.js";
+export interface MatchingStrategy {
+    find(content: string, oldText: string): ReturnType<typeof fuzzyFindText>;
+}
+declare const editSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    oldText: import("@sinclair/typebox").TString;
+    newText: import("@sinclair/typebox").TString;
+    replaceAll: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export interface EditToolDetails {
+    /** Formatted diff showing what changed. */
+    diff: string;
+    /** First changed line (1-based) in the new file; handy for positioning the cursor there. */
+    firstChangedLine?: number;
+}
+/**
+ * Pluggable filesystem callbacks for the edit tool. Override them to direct
+ * edits at an alternate backend, for instance an SSH or remote-mount layer.
+ */
+export interface EditOperations {
+    /** Read a file's raw bytes. */
+    readFile: (absolutePath: string) => Promise<Buffer>;
+    /** Write replacement text to a file. */
+    writeFile: (absolutePath: string, content: string) => Promise<void>;
+    /** Verify the file is both readable and writable, raising if not. */
+    access: (absolutePath: string) => Promise<void>;
+}
+export interface EditToolOptions {
+    /** Swap out the filesystem callbacks; the local disk is used by default. */
+    operations?: EditOperations;
+    matchingStrategy?: MatchingStrategy;
+    /**
+     * Optional read-before-edit gate store. When present, the edit is refused
+     * unless the file was read this session and has not drifted on disk since.
+     * Absent → no gate (no-op), preserving the prior behaviour exactly.
+     */
+    readState?: ReadStateHandle;
+    /**
+     * Optional file-checkpoint sink. When present, the file's ORIGINAL
+     * pre-edit on-disk content is captured exactly once before the edit is
+     * applied, so a later rewind can roll the working tree back. The edit tool
+     * only ever targets an existing file, so the snapshot is its old bytes (never
+     * `null`). Absent → no snapshot (no-op).
+     */
+    checkpoint?: CheckpointHandle;
+}
+export declare function createEditTool(cwd: string, options?: EditToolOptions): AgentTool<typeof editSchema>;
+/** Ready-to-use edit tool bound to the current working directory. */
+export declare const editTool: AgentTool<import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    oldText: import("@sinclair/typebox").TString;
+    newText: import("@sinclair/typebox").TString;
+    replaceAll: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>, any>;
+export {};

package/dist/types/facade/bot/actions/edit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/facade/bot/actions/find.d.ts

@@ -0,0 +1,27 @@
+import type { AgentTool } from "../types.js";
+import { type TruncationResult } from "./truncate.js";
+declare const findSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export interface FindToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+}
+export interface FindToolOptions {
+    /** Backend hooks to use. When omitted, the local filesystem is walked. */
+    operations?: any;
+    exclude?: string[];
+    sort?: "asc" | "desc";
+}
+export declare function createFindTool(cwd: string, options?: FindToolOptions): AgentTool<typeof findSchema>;
+/** Ready-made find tool bound to the process working directory. */
+export declare const findTool: AgentTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};

package/dist/types/facade/bot/actions/find.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/facade/bot/actions/grep.d.ts

@@ -0,0 +1,53 @@
+import type { AgentTool } from "../types.js";
+import { type TruncationResult } from "./truncate.js";
+declare const grepSchema: import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    before: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    after: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export interface GrepToolDetails {
+    truncation?: TruncationResult;
+    matchLimitReached?: number;
+    linesTruncated?: boolean;
+}
+/**
+ * Pluggable I/O backend for the grep tool. Pass a custom implementation to make
+ * the search read from a target other than the local filesystem, such as a
+ * remote machine reached through a transport layer.
+ */
+export interface GrepOperations {
+    /** Return true when the path points at a directory. Throws if it does not exist. */
+    isDirectory: (absolutePath: string) => Promise<boolean> | boolean;
+    /** Load a file's contents as text so neighboring context lines can be rendered. */
+    readFile: (absolutePath: string) => Promise<string> | string;
+    /** List the immediate child names of a directory. */
+    readdir: (absolutePath: string) => Promise<string[]> | string[];
+}
+export interface GrepToolOptions {
+    /** Backend hooks to use. When omitted, the local filesystem is searched. */
+    operations?: GrepOperations;
+}
+export declare function createGrepTool(cwd: string, options?: GrepToolOptions): AgentTool<typeof grepSchema>;
+/** Ready-made grep tool bound to the process working directory. */
+export declare const grepTool: AgentTool<import("@sinclair/typebox").TObject<{
+    pattern: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    before: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    after: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    output_mode: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"content">, import("@sinclair/typebox").TLiteral<"files_with_matches">, import("@sinclair/typebox").TLiteral<"count">]>>;
+    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};

package/dist/types/facade/bot/actions/grep.test.d.ts

@@ -0,0 +1 @@
+export {};