apunkt/rowboat
1
0
Fork 0
mirror of https://github.com/rowboatlabs/rowboat.git synced 2026-05-16 18:25:17 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove at rowbot block for single tasks

Browse source
This commit is contained in:
Arjun 2026-03-19 00:40:49 +05:30
parent 05096f1383
commit 5e1debad6a
1 changed files with 67 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

147
apps/x/apps/renderer/src/components/markdown-editor.tsx
View file

@ -930,7 +930,7 @@ export function MarkdownEditor({
}
if (activeRowboatMention) {
// Insert block with processing state immediately
// Insert a temporary processing block
const blockData: Record<string, unknown> = { instruction, processing: true }
const insertFrom = activeRowboatMention.range.from
@ -951,21 +951,27 @@ export function MarkdownEditor({
setActiveRowboatMention(null)
setRowboatAnchorTop(null)
// Find the taskBlock we just inserted so we can update it later
const processingData = JSON.stringify(blockData)
let taskBlockPos: number | null = null
editor.state.doc.descendants((node, pos) => {
if (taskBlockPos !== null) return false
if (node.type.name === 'taskBlock' && node.attrs.data === processingData) {
taskBlockPos = pos
return false
}
})
// Get editor content for the agent
const editorContent = editor.storage.markdown?.getMarkdown?.() ?? ''
// Call the assistant agent asynchronously
// Helper to find the processing block
const findProcessingBlock = (): number | null => {
let pos: number | null = null
editor.state.doc.descendants((node, p) => {
if (pos !== null) return false
if (node.type.name === 'taskBlock') {
try {
const data = JSON.parse(node.attrs.data || '{}')
if (data.instruction === instruction && data.processing === true) {
pos = p
return false
}
} catch { /* skip */ }
}
})
return pos
}
try {
const result = await window.ipc.invoke('inline-task:process', {
instruction,
@ -973,89 +979,70 @@ export function MarkdownEditor({
notePath: notePath ?? '',
})
// Update the block: remove processing, add schedule if any
const updatedData: Record<string, unknown> = { instruction }
if (result.schedule) {
updatedData.schedule = result.schedule
updatedData['schedule-label'] = result.scheduleLabel
const currentPos = findProcessingBlock()
if (currentPos === null) return
// Mark note as live if there's a schedule
const node = editor.state.doc.nodeAt(currentPos)
if (!node) return
if (result.schedule) {
// Scheduled task: keep the block, update with schedule info
const updatedData: Record<string, unknown> = {
instruction,
schedule: result.schedule,
'schedule-label': result.scheduleLabel,
}
const tr = editor.state.tr.setNodeMarkup(currentPos, undefined, {
data: JSON.stringify(updatedData),
})
editor.view.dispatch(tr)
// Mark note as live
if (onFrontmatterChange) {
const fields = extractAllFrontmatterValues(frontmatter ?? null)
fields['live_note'] = 'true'
onFrontmatterChange(buildFrontmatter(fields))
}
}
// Find the processing block again (position may have shifted)
let currentPos: number | null = null
editor.state.doc.descendants((node, pos) => {
if (currentPos !== null) return false
if (node.type.name === 'taskBlock') {
try {
const data = JSON.parse(node.attrs.data || '{}')
if (data.instruction === instruction && data.processing === true) {
currentPos = pos
return false
// Insert response text below the block if any
if (result.response) {
let afterPos: number | null = null
editor.state.doc.descendants((n, p) => {
if (afterPos !== null) return false
if (n.type.name === 'taskBlock') {
try {
const data = JSON.parse(n.attrs.data || '{}')
if (data.instruction === instruction && !data.processing) {
afterPos = p + n.nodeSize
return false
}
} catch { /* skip */ }
}
} catch { /* skip */ }
}
})
if (currentPos !== null) {
const node = editor.state.doc.nodeAt(currentPos)
if (node) {
// Update the block data (remove processing, add schedule)
const tr = editor.state.tr.setNodeMarkup(currentPos, undefined, {
data: JSON.stringify(updatedData),
})
editor.view.dispatch(tr)
// Insert response text below the block as rendered markdown
if (result.response) {
// Re-find position after the dispatch above
let afterPos: number | null = null
editor.state.doc.descendants((n, pos) => {
if (afterPos !== null) return false
if (n.type.name === 'taskBlock') {
try {
const data = JSON.parse(n.attrs.data || '{}')
if (data.instruction === instruction && !data.processing) {
afterPos = pos + n.nodeSize
return false
}
} catch { /* skip */ }
}
})
if (afterPos !== null) {
editor.chain().insertContentAt(afterPos, result.response).run()
}
if (afterPos !== null) {
editor.chain().insertContentAt(afterPos, result.response).run()
}
}
} else {
// One-time task: remove the processing block, insert response in its place
const insertPos = currentPos
const deleteEnd = currentPos + node.nodeSize
editor.chain().focus().deleteRange({ from: insertPos, to: deleteEnd }).run()
if (result.response) {
editor.chain().insertContentAt(insertPos, result.response).run()
}
}
} catch (error) {
console.error('[RowboatAdd] Processing failed:', error)
// Remove processing state on error
let currentPos: number | null = null
editor.state.doc.descendants((node, pos) => {
if (currentPos !== null) return false
if (node.type.name === 'taskBlock') {
try {
const data = JSON.parse(node.attrs.data || '{}')
if (data.instruction === instruction && data.processing === true) {
currentPos = pos
return false
}
} catch { /* skip */ }
}
})
// Remove the processing block on error
const currentPos = findProcessingBlock()
if (currentPos !== null) {
const tr = editor.state.tr.setNodeMarkup(currentPos, undefined, {
data: JSON.stringify({ instruction }),
})
editor.view.dispatch(tr)
const node = editor.state.doc.nodeAt(currentPos)
if (node) {
editor.chain().focus().deleteRange({ from: currentPos, to: currentPos + node.nodeSize }).run()
}
}
}
}