indusagi 0.12.32 → 0.12.34

package/dist/types/facade/bot/actions/crew/task-store.d.ts

@@ -0,0 +1,88 @@
+export type TaskStatus = "pending" | "in_progress" | "completed";
+export interface TeamTask {
+    id: string;
+    subject: string;
+    description: string;
+    owner?: string;
+    status: TaskStatus;
+    blocks: string[];
+    blockedBy: string[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function getTaskListDir(teamDir: string, taskListId: string): string;
+export declare function shortTaskId(id: string): string;
+export declare function formatTaskLine(t: TeamTask, opts?: {
+    blocked?: boolean;
+}): string;
+export declare function listTasks(teamDir: string, taskListId: string): Promise<TeamTask[]>;
+export declare function getTask(teamDir: string, taskListId: string, taskId: string): Promise<TeamTask | null>;
+export declare function createTask(teamDir: string, taskListId: string, input: {
+    subject: string;
+    description: string;
+    owner?: string;
+}): Promise<TeamTask>;
+export declare function updateTask(teamDir: string, taskListId: string, taskId: string, updater: (current: TeamTask) => TeamTask): Promise<TeamTask | null>;
+export declare function isTaskBlocked(teamDir: string, taskListId: string, task: TeamTask): Promise<boolean>;
+export declare function agentHasActiveTask(teamDir: string, taskListId: string, agentName: string): Promise<boolean>;
+/**
+ * Claim a specific task (owner must be empty).
+ * Returns the updated task if claim succeeded, otherwise null.
+ */
+export declare function claimTask(teamDir: string, taskListId: string, taskId: string, agentName: string, opts?: {
+    checkAgentBusy?: boolean;
+}): Promise<TeamTask | null>;
+/**
+ * Start an assigned task (owner matches), marking it in_progress.
+ */
+export declare function startAssignedTask(teamDir: string, taskListId: string, taskId: string, agentName: string): Promise<TeamTask | null>;
+export declare function completeTask(teamDir: string, taskListId: string, taskId: string, agentName: string, result?: string): Promise<TeamTask | null>;
+export declare function unassignTask(teamDir: string, taskListId: string, taskId: string, agentName: string, reason?: string, extraMetadata?: Record<string, unknown>): Promise<TeamTask | null>;
+/** Reset all non-completed tasks owned by agent back to pending + unowned. */
+export declare function unassignTasksForAgent(teamDir: string, taskListId: string, agentName: string, reason?: string): Promise<number>;
+/**
+ * Find and claim the first available task:
+ * - pending
+ * - unowned
+ * - unblocked
+ */
+export declare function claimNextAvailableTask(teamDir: string, taskListId: string, agentName: string, opts?: {
+    checkAgentBusy?: boolean;
+}): Promise<TeamTask | null>;
+export type TaskDependencyOpResult = {
+    ok: true;
+    task: TeamTask;
+    dependency: TeamTask;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Add a dependency edge: taskId is blockedBy depId (and depId blocks taskId).
+ */
+export declare function addTaskDependency(teamDir: string, taskListId: string, taskId: string, depId: string): Promise<TaskDependencyOpResult>;
+/**
+ * Remove dependency edge: taskId no longer blockedBy depId (and depId no longer blocks taskId).
+ */
+export declare function removeTaskDependency(teamDir: string, taskListId: string, taskId: string, depId: string): Promise<TaskDependencyOpResult>;
+export type TaskClearMode = "completed" | "all";
+export interface ClearTasksResult {
+    mode: TaskClearMode;
+    taskListId: string;
+    taskListDir: string;
+    deletedTaskIds: string[];
+    skippedTaskIds: string[];
+    errors: Array<{
+        file: string;
+        error: string;
+    }>;
+}
+/**
+ * Delete task JSON files from the task list directory.
+ *
+ * Safety properties:
+ * - Only deletes `*.json` files inside `<teamDir>/tasks/<taskListId>/`.
+ * - Refuses to operate if the resolved task list directory is not within `teamDir`.
+ */
+export declare function clearTasks(teamDir: string, taskListId: string, mode?: TaskClearMode): Promise<ClearTasksResult>;

package/dist/types/facade/bot/actions/crew/team-attach-claim.d.ts

@@ -0,0 +1,35 @@
+export declare const TEAM_ATTACH_CLAIM_FILE = ".attach-claim.json";
+export declare const TEAM_ATTACH_CLAIM_STALE_MS = 30000;
+export interface TeamAttachClaim {
+    holderSessionId: string;
+    claimedAt: string;
+    heartbeatAt: string;
+    pid: number;
+}
+export declare function assessAttachClaimFreshness(claim: TeamAttachClaim, nowMs?: number, staleMs?: number): {
+    isStale: boolean;
+    ageMs: number;
+};
+export declare function readTeamAttachClaim(teamDir: string): Promise<TeamAttachClaim | null>;
+export type AcquireTeamAttachClaimResult = {
+    ok: true;
+    claim: TeamAttachClaim;
+    replacedClaim?: TeamAttachClaim;
+} | {
+    ok: false;
+    reason: "claimed_by_other";
+    claim: TeamAttachClaim;
+};
+export declare function acquireTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    force?: boolean;
+    staleMs?: number;
+    nowMs?: number;
+}): Promise<AcquireTeamAttachClaimResult>;
+export type TeamAttachClaimHeartbeatResult = "updated" | "not_owner" | "missing";
+export declare function heartbeatTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    nowMs?: number;
+}): Promise<TeamAttachClaimHeartbeatResult>;
+export type TeamAttachClaimReleaseResult = "released" | "not_owner" | "none";
+export declare function releaseTeamAttachClaim(teamDir: string, holderSessionId: string, opts?: {
+    force?: boolean;
+}): Promise<TeamAttachClaimReleaseResult>;

package/dist/types/facade/bot/actions/crew/team-config.d.ts

@@ -0,0 +1,54 @@
+export type TeamsStyle = string;
+export interface TeamMember {
+    name: string;
+    role: "lead" | "worker";
+    addedAt: string;
+    status: "online" | "offline";
+    lastSeenAt?: string;
+    /** Optional: teammate session file path (useful for debugging) */
+    sessionFile?: string;
+    /** Optional: teammate working directory */
+    cwd?: string;
+    /** Freeform metadata for future use */
+    meta?: Record<string, unknown>;
+}
+export type TeamHooksFailureAction = "warn" | "followup" | "reopen" | "reopen_followup";
+export type TeamHooksFollowupOwnerPolicy = "member" | "lead" | "none";
+export interface TeamHooksPolicy {
+    failureAction?: TeamHooksFailureAction;
+    maxReopensPerTask?: number;
+    followupOwner?: TeamHooksFollowupOwnerPolicy;
+}
+export interface TeamConfig {
+    version: 1;
+    teamId: string;
+    /** Task list namespace identifier (Claude-style: often teamName or parentSessionId) */
+    taskListId: string;
+    /** Internal leader agent id (mailbox name, member name, etc.) */
+    leadName: string;
+    /** Optional UI/UX style. If omitted, treat as "normal". */
+    style?: TeamsStyle;
+    /** Optional per-team hooks policy override (env remains fallback). */
+    hooks?: TeamHooksPolicy;
+    createdAt: string;
+    updatedAt: string;
+    members: TeamMember[];
+}
+export declare function getTeamConfigPath(teamDir: string): string;
+export declare function loadTeamConfig(teamDir: string): Promise<TeamConfig | null>;
+export declare function ensureTeamConfig(teamDir: string, init: {
+    teamId: string;
+    taskListId: string;
+    leadName: string;
+    style?: TeamsStyle;
+}): Promise<TeamConfig>;
+export declare function setTeamStyle(teamDir: string, style: TeamsStyle): Promise<TeamConfig | null>;
+export declare function updateTeamHooksPolicy(teamDir: string, updater: (current: TeamHooksPolicy) => TeamHooksPolicy | undefined): Promise<TeamConfig | null>;
+export declare function upsertMember(teamDir: string, member: Omit<TeamMember, "name" | "addedAt"> & {
+    name: string;
+    addedAt?: string;
+}): Promise<TeamConfig>;
+export declare function setMemberStatus(teamDir: string, memberName: string, status: "online" | "offline", extra?: {
+    lastSeenAt?: string;
+    meta?: Record<string, unknown>;
+}): Promise<TeamConfig | null>;

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.d.ts

@@ -0,0 +1,41 @@
+import type { AgentTool } from "../types.js";
+import { fuzzyFindText } from "./edit-diff.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;
+}>;
+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;
+}
+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;
+}>, any>;
+export {};

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

@@ -0,0 +1,25 @@
+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>;
+    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>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};

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

@@ -0,0 +1,43 @@
+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>;
+    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>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>, any>;
+export {};