harness-write 0.1.1

Write/Edit/MultiEdit tool for AI agent harnesses — atomic write, read-before-edit ledger, OLD_STRING_NOT_UNIQUE with match locations, OLD_STRING_NOT_FOUND with fuzzy candidates, sequential multi-edit pipeline
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use harness_core::{PermissionPolicy, ToolError};
use serde::{Deserialize, Serialize};
use std::sync::Arc;

use crate::ledger::Ledger;

#[derive(Clone)]
pub struct WriteSessionConfig {
    pub cwd: String,
    pub permissions: PermissionPolicy,
    pub ledger: Arc<dyn Ledger>,
    pub max_file_size: Option<u64>,
}

impl WriteSessionConfig {
    pub fn new(
        cwd: impl Into<String>,
        permissions: PermissionPolicy,
        ledger: Arc<dyn Ledger>,
    ) -> Self {
        Self {
            cwd: cwd.into(),
            permissions,
            ledger,
            max_file_size: None,
        }
    }
}

impl std::fmt::Debug for WriteSessionConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("WriteSessionConfig")
            .field("cwd", &self.cwd)
            .field("permissions", &self.permissions)
            .finish()
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MatchLocation {
    pub line: usize,
    pub preview: String,
    pub context_before: Vec<String>,
    pub context_after: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FuzzyCandidate {
    pub line: usize,
    pub score: f64,
    pub preview: String,
    pub context_before: Vec<String>,
    pub context_after: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WriteMeta {
    pub path: String,
    pub bytes_written: u64,
    pub sha256: String,
    pub mtime_ms: u64,
    pub created: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub previous_sha256: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EditMeta {
    pub path: String,
    pub replacements: usize,
    pub bytes_delta: i64,
    pub sha256: String,
    pub mtime_ms: u64,
    pub previous_sha256: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warnings: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiEditMeta {
    pub path: String,
    pub edits_applied: usize,
    pub total_replacements: usize,
    pub bytes_delta: i64,
    pub sha256: String,
    pub mtime_ms: u64,
    pub previous_sha256: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub warnings: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PreviewMeta {
    pub path: String,
    pub would_write_bytes: u64,
    pub bytes_delta: i64,
    pub previous_sha256: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AnyMeta {
    Write(WriteMeta),
    Edit(EditMeta),
    MultiEdit(MultiEditMeta),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TextWriteResult {
    pub output: String,
    pub meta: AnyMeta,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PreviewResult {
    pub output: String,
    pub diff: String,
    pub meta: PreviewMeta,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorResult {
    pub error: ToolError,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum WriteResult {
    #[serde(rename = "text")]
    Text(TextWriteResult),
    #[serde(rename = "error")]
    Error(ErrorResult),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum EditResult {
    #[serde(rename = "text")]
    Text(TextWriteResult),
    #[serde(rename = "preview")]
    Preview(PreviewResult),
    #[serde(rename = "error")]
    Error(ErrorResult),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum MultiEditResult {
    #[serde(rename = "text")]
    Text(TextWriteResult),
    #[serde(rename = "preview")]
    Preview(PreviewResult),
    #[serde(rename = "error")]
    Error(ErrorResult),
}