feat: resolve all 12 open GitHub issues + v0.7.6 release

Fixes:
- #54: HASHLINE_URL CLI silent → fallback to result.content[].text
- #55: find-block .verse → indent + brace + fallback resolver
- #56: SWAP N:HASH: silently fails → consume_optional_colon_with_hash
- #57: atomic_write slow → --fast flag skips fsync
- #58: patch exits 0 on invalid format → EmptyPatch error exit 1
- #59: log unbounded → rotation via HASHLINE_LOG_MAX_BYTES
- #60: MCP tool names hashline_* → read/patch/find_block (legacy aliases kept)
- #61: --dry-run shows full file → unified diff output
- #62: --json returns nothing → structured {success, file, lines}
- #63: patch inline-only → stdin (-) and @path support
- #64: daemon artifacts → SIGINT/SIGTERM cleanup socket+pid
- #65: str_replace missing → new hashline replace command

Co-Authored-By: Claude <noreply@anthropic.com>

Author: quangdang46

.beads/issues.jsonl

@@ -241,9 +241,11 @@ everything you need in one place.
 `hashline` ships with a stdio MCP server exposing 3 tools:
 
 ```
-hashline_read        — Read a file with [path#HASH] header + numbered lines
-hashline_patch       — Apply a patch (SWAP/DEL/INS.*/BLK.*)
-hashline_find_block  — Find enclosing syntactic block around an anchor
+read                 — Read a file with [path#HASH] header + numbered lines
+patch                — Apply a patch (SWAP/DEL/INS.*/BLK.*)
+find_block           — Find enclosing syntactic block around an anchor
+
+(legacy aliases `hashline_read`, `hashline_patch`, `hashline_find_block` remain accepted)
 ```
 
 ```bash

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "hashline"
-version = "0.7.5"
+version = "0.7.6"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

README.md

@@ -23,6 +23,7 @@ pub enum Commands {
     Guide(GuideCmd),
     Serve(ServeCmd),
     Mcp(McpCmd),
+    Replace(ReplaceCmd),
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, Parser)]
@@ -44,6 +45,11 @@ pub struct PatchCmd {
     pub dry_run: bool,
     #[arg(long)]
     pub json: bool,
+    #[arg(
+        long,
+        help = "Skip fsync for faster writes (skip --safe/atomic behavior)"
+    )]
+    pub fast: bool,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, Parser)]
@@ -57,6 +63,18 @@ pub struct FindBlockCmd {
     pub pretty: bool,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize, Parser)]
+#[command(about = "Replace old_string with new_string in file (str_replace-style)")]
+pub struct ReplaceCmd {
+    pub file: PathBuf,
+    pub old_string: String,
+    pub new_string: String,
+    #[arg(long)]
+    pub json: bool,
+    #[arg(long)]
+    pub safe: bool,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize, Parser)]
 #[command(about = "Show interactive user guide")]
 pub struct GuideCmd {

crates/core/Cargo.toml

@@ -42,6 +42,22 @@ pub fn atomic_write(path: &Path, bytes: &[u8]) -> Result<(), HashlineError> {
     atomic_write_with(path, |file| file.write_all(bytes))
 }
 
+/// Fast variant of atomic_write that skips fsync and uses a simple
+/// read-modify-write instead of temp-file + rename. Suitable for agent
+/// use cases where crash safety is not critical (the agent can always
+/// re-read and re-edit on failure).
+pub fn fast_write(path: &Path, bytes: &[u8]) -> Result<(), HashlineError> {
+    use std::io::Write;
+    let mut file = std::fs::OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .create(true)
+        .open(path)?;
+    file.write_all(bytes)?;
+    // No sync_all / sync_parent_directory call.
+    Ok(())
+}
+
 pub fn atomic_write_with<F>(path: &Path, write_contents: F) -> Result<(), HashlineError>
 where
     F: FnOnce(&mut fs::File) -> io::Result<()>,

crates/core/src/cli.rs

@@ -97,7 +97,7 @@ pub fn find_block_boundaries(
 
     let (language, block_start, block_end) = match extension {
         "py" => find_python_block(entries, anchor_index)?,
-        "verse" => find_python_block(entries, anchor_index)?,
+        "verse" => find_verse_block(entries, anchor_index)?,
         "rb" => find_ruby_block(entries, anchor_index)?,
         "rs" | "js" | "ts" | "tsx" | "jsx" | "go" | "java" | "c" | "cpp" | "h" | "hpp" | "cs"
         | "kt" | "kts" | "swift" | "scala" | "dart" | "zig" | "m" | "mm" => {
@@ -300,6 +300,77 @@ fn find_indent_block(
     Ok((start, end))
 }
 
+fn find_verse_block(
+    entries: &[crate::document::LineEntry],
+    anchor_index: usize,
+) -> Result<(Option<String>, usize, usize), HashlineError> {
+    // Verse combines indented class/method bodies (`base_x := class():` /
+    // `OnBegin():void=`) with brace blocks (`using { /Verse... }`,
+    // `if (X) { ... }`). Try indent first (most blocks are class bodies),
+    // then brace-balanced for anchor lines that live inside `{ }`.
+    if let Ok((s, e)) = find_verse_indent_block(entries, anchor_index) {
+        return Ok((Some("Verse".into()), s, e));
+    }
+    if let Ok((s, e)) = find_brace_block(entries, anchor_index, "verse") {
+        return Ok((Some("Verse".into()), s, e));
+    }
+    // Last resort: return the whole file as a single block (top-level anchor).
+    Ok((Some("Verse".into()), 0, entries.len().saturating_sub(1)))
+}
+
+fn find_verse_indent_block(
+    entries: &[crate::document::LineEntry],
+    anchor_index: usize,
+) -> Result<(usize, usize), HashlineError> {
+    let anchor_indent = leading_whitespace(&entries[anchor_index].content);
+
+    // Walk backwards for the first non-empty line with strictly less
+    // indentation. If we never find one (anchor is at top of file), look
+    // forward instead: the first non-empty line with indent <= anchor_indent
+    // marks the block end, and the block extends from anchor_index..end.
+    let mut start: Option<usize> = None;
+    for i in (0..anchor_index).rev() {
+        if entries[i].content.trim().is_empty() {
+            continue;
+        }
+        let indent = leading_whitespace(&entries[i].content);
+        if indent < anchor_indent {
+            start = Some(i);
+            break;
+        }
+    }
+    let (start, start_indent) = if let Some(s) = start {
+        (s, leading_whitespace(&entries[s].content))
+    } else {
+        // Top-of-file anchor: block extends back to line 0.
+        (0, leading_whitespace(&entries[0].content))
+    };
+
+    let mut end = entries.len().saturating_sub(1);
+    let mut found_end = false;
+    for i in (start + 1)..entries.len() {
+        let entry = &entries[i];
+        let trimmed = entry.content.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        // Verse treats lines beginning with `#` as a comment-like marker,
+        // matching the Python rule. There is no native block-comment in
+        // Verse, so we only need to skip `#` rows.
+        if trimmed.starts_with('#') {
+            continue;
+        }
+        let indent = leading_whitespace(&entry.content);
+        if indent <= start_indent {
+            end = i.saturating_sub(1);
+            found_end = true;
+            break;
+        }
+    }
+    let _ = found_end;
+    Ok((start, end))
+}
+
 fn find_python_block(
     entries: &[crate::document::LineEntry],
     anchor_index: usize,
@@ -493,6 +564,32 @@ mod tests {
         assert_eq!(payload.block_lines[2].content, "}");
     }
 
+    #[test]
+    fn test_verse_top_level_using() {
+        let content = "using { /Verse.org/Simulation }\nusing { /Fortnite.com/Devices }\n\nbase_x := class():\n    x:int = 0\n";
+        let (fc, entries) = make_fc(content, "test.verse");
+        // Anchor on the top-level `using` should not fail.
+        let payload = find_block_payload(&fc, &entries, &anchor_for(1, &entries)).unwrap();
+        assert_eq!(payload.language.as_deref(), Some("Verse"));
+        assert!(!payload.block_lines.is_empty());
+    }
+
+    #[test]
+    fn test_verse_class_body() {
+        let content = "using { /Verse.org/Simulation }\n\nsignal_device := class(creative_device):\n    var Count:int = 0\n    OnBegin<override>()<suspends>:void=\n        Count += 1\n        Print(\"ok\")\n";
+        let (fc, entries) = make_fc(content, "test.verse");
+        // Anchor inside the class body (the var Count line) should resolve
+        // to the enclosing class block.
+        let payload = find_block_payload(&fc, &entries, &anchor_for(4, &entries)).unwrap();
+        assert_eq!(payload.language.as_deref(), Some("Verse"));
+        assert!(
+            payload
+                .block_lines
+                .iter()
+                .any(|l| l.content.starts_with("signal_device"))
+        );
+    }
+
     #[test]
     fn test_go_block() {
         let content = "func main() {\n\tif true {\n\t\tfmt.Println(\"ok\")\n\t}\n}\n";

crates/core/src/commands/common.rs

@@ -115,9 +115,9 @@ pub fn run<W: Write, E: Write>(
   hashline mcp
 
   Runs a stdio JSON-RPC server exposing 3 tools:
-    • hashline_read       — read file with snapshot hash
-    • hashline_patch      — apply patch (SWAP/DEL/INS.*/BLK.*)
-    • hashline_find_block — find enclosing syntactic block
+    • read       — read file with snapshot hash
+    • patch      — apply patch (SWAP/DEL/INS.*/BLK.*)
+    • find_block — find enclosing syntactic block
 
   Configure in claude_desktop_config.json / .cursor/mcp.json:
     {

crates/core/src/commands/find_block.rs

@@ -3,4 +3,5 @@ pub mod find_block;
 pub mod guide;
 pub mod patch;
 pub mod read;
+pub mod replace;
 pub mod serve;