From e72fb0c0f4f631fd4def5b8f56b20ded47492660 Mon Sep 17 00:00:00 2001 From: Nick Krumholz Date: Mon, 15 Jun 2026 17:26:35 -0500 Subject: [PATCH] =?UTF-8?q?0.0.2=20=E2=80=94=20always-visible=20commands?= =?UTF-8?q?=20+=20ribbon=20(fix:=20no=20commands=20found)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- main.js | 138 ++++++++++++++++++++++++++---------------------- manifest.json | 2 +- package.json | 2 +- src/main.ts | 141 +++++++++++++++++++++++++++++--------------------- versions.json | 3 +- 5 files changed, 162 insertions(+), 124 deletions(-) diff --git a/main.js b/main.js index 522d2de..e48f655 100644 --- a/main.js +++ b/main.js @@ -178,82 +178,98 @@ var LocatorModal = class extends import_obsidian.Modal { }; var CiteEnginePlugin = class extends import_obsidian.Plugin { async onload() { + this.addRibbonIcon("quote-glyph", "Cite Engine: cite a passage", () => this.cite()); this.addCommand({ id: "stamp-source", name: "Stamp source (assign citekey + block ids)", - editorCallback: async (_editor, ctx) => { - const file = ctx.file; - if (!file) return; - const text = await this.app.vault.read(file); - const { fm, body } = splitFrontmatter(text); - if (!fm.citekey) { - fm.citekey = generateCitekey({ - author: String(fm.author ?? ""), - year: String(fm.year ?? ""), - title: String(fm.title ?? file.basename) - }); - } - const { content } = stampNote(body); - await this.app.vault.modify(file, joinFrontmatter(fm, content)); - new import_obsidian.Notice(`Stamped as ${fm.citekey}`); - } + callback: () => this.stampSource() }); this.addCommand({ id: "cite", name: "Cite a passage", - editorCallback: async (editor) => { - const reg = await buildRegistry(this.app); - const items = []; - for (const [citekey, entry] of Object.entries(reg)) { - for (const [blockId, text] of Object.entries(entry.blocks)) { - items.push({ citekey, blockId, text }); - } - } - if (items.length === 0) { - new import_obsidian.Notice("No stamped sources yet. Run \u201CStamp source\u201D on a clipped note first."); - return; - } - new BlockPicker(this.app, items, (choice) => { - new LocatorModal(this.app, (locator) => { - const cite = insertCitation(reg, { - citekey: choice.citekey, - blockId: choice.blockId, - locator, - quote: choice.text - }); - editor.replaceSelection(cite); - }).open(); - }).open(); - } + callback: () => this.cite() }); this.addCommand({ id: "integrity-check", name: "Integrity check (this note)", - editorCallback: async (_editor, ctx) => { - const file = ctx.file; - if (!file) return; - const reg = await buildRegistry(this.app); - const text = await this.app.vault.read(file); - const issues = checkIntegrity(text, reg); - if (issues.length === 0) { - new import_obsidian.Notice("\u2713 All citations resolve. No drift."); - return; - } - const lines = issues.map((i) => { - if (i.kind === "drift") return `DRIFT ${i.citekey}#^${i.blockId} + callback: () => this.integrityCheck() + }); + } + /** Active markdown editor + its file, or null with a guiding notice. */ + activeNote() { + const ae = this.app.workspace.activeEditor; + if (ae?.editor && ae.file) return { editor: ae.editor, file: ae.file }; + new import_obsidian.Notice("Open a markdown note first, then run this Cite Engine command."); + return null; + } + async stampSource() { + const ctx = this.activeNote(); + if (!ctx) return; + const { file } = ctx; + const text = await this.app.vault.read(file); + const { fm, body } = splitFrontmatter(text); + if (!fm.citekey) { + fm.citekey = generateCitekey({ + author: String(fm.author ?? ""), + year: String(fm.year ?? ""), + title: String(fm.title ?? file.basename) + }); + } + const { content } = stampNote(body); + await this.app.vault.modify(file, joinFrontmatter(fm, content)); + new import_obsidian.Notice(`Stamped as ${fm.citekey}`); + } + async cite() { + const ctx = this.activeNote(); + if (!ctx) return; + const { editor } = ctx; + const reg = await buildRegistry(this.app); + const items = []; + for (const [citekey, entry] of Object.entries(reg)) { + for (const [blockId, text] of Object.entries(entry.blocks)) { + items.push({ citekey, blockId, text }); + } + } + if (items.length === 0) { + new import_obsidian.Notice("No stamped sources yet. Run \u201CStamp source\u201D on a clipped note first."); + return; + } + new BlockPicker(this.app, items, (choice) => { + new LocatorModal(this.app, (locator) => { + const cite = insertCitation(reg, { + citekey: choice.citekey, + blockId: choice.blockId, + locator, + quote: choice.text + }); + editor.replaceSelection(cite); + }).open(); + }).open(); + } + async integrityCheck() { + const ctx = this.activeNote(); + if (!ctx) return; + const { file } = ctx; + const reg = await buildRegistry(this.app); + const text = await this.app.vault.read(file); + const issues = checkIntegrity(text, reg); + if (issues.length === 0) { + new import_obsidian.Notice("\u2713 All citations resolve. No drift."); + return; + } + const lines = issues.map((i) => { + if (i.kind === "drift") return `DRIFT ${i.citekey}#^${i.blockId} quoted: ${i.expected} source: ${i.actual}`; - if (i.kind === "unresolved-block") return `MISSING BLOCK ${i.citekey}#^${i.blockId}`; - return `UNKNOWN SOURCE ${i.citekey}`; - }); - const report = `# Integrity report \u2014 ${file.basename} + if (i.kind === "unresolved-block") return `MISSING BLOCK ${i.citekey}#^${i.blockId}`; + return `UNKNOWN SOURCE ${i.citekey}`; + }); + const report = `# Integrity report \u2014 ${file.basename} ${lines.join("\n\n")} `; - await this.app.vault.create(`Integrity report \u2014 ${file.basename}.md`, report); - new import_obsidian.Notice(`${issues.length} issue(s). See integrity report.`); - } - }); + await this.app.vault.create(`Integrity report \u2014 ${file.basename}.md`, report); + new import_obsidian.Notice(`${issues.length} issue(s). See integrity report.`); } }; -//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/core.ts"],
  "sourcesContent": ["import {\n  App,\n  Editor,\n  FuzzySuggestModal,\n  MarkdownFileInfo,\n  Modal,\n  Notice,\n  Plugin,\n  Setting,\n  parseYaml,\n  stringifyYaml,\n} from \"obsidian\";\nimport {\n  generateCitekey,\n  stampNote,\n  insertCitation,\n  checkIntegrity,\n  type Registry,\n} from \"./core\";\n\nconst FM_RE = /^---\\n([\\s\\S]*?)\\n---\\n?/;\n\nfunction splitFrontmatter(text: string): { fm: Record<string, unknown>; body: string } {\n  text = text.replace(/^\uFEFF/, \"\").replace(/\\r\\n/g, \"\\n\");\n  const m = text.match(FM_RE);\n  if (!m) return { fm: {}, body: text };\n  return { fm: (parseYaml(m[1]) as Record<string, unknown>) ?? {}, body: text.slice(m[0].length) };\n}\n\nfunction joinFrontmatter(fm: Record<string, unknown>, body: string): string {\n  return `---\\n${stringifyYaml(fm)}---\\n${body}`;\n}\n\n/** Build the closed-corpus registry from every note carrying a citekey. */\nasync function buildRegistry(app: App): Promise<Registry> {\n  const reg: Registry = {};\n  for (const file of app.vault.getMarkdownFiles()) {\n    const cache = app.metadataCache.getFileCache(file);\n    const citekey = cache?.frontmatter?.citekey as string | undefined;\n    if (!citekey) continue;\n    const text = await app.vault.cachedRead(file);\n    const { fm, body } = splitFrontmatter(text);\n    const { blocks } = stampNote(body);\n    reg[citekey] = {\n      meta: {\n        citekey,\n        title: String(fm.title ?? file.basename),\n        author: String(fm.author ?? \"\"),\n        year: String(fm.year ?? \"\"),\n        url: fm.url ? String(fm.url) : undefined,\n      },\n      blocks,\n    };\n  }\n  return reg;\n}\n\ninterface BlockChoice {\n  citekey: string;\n  blockId: string;\n  text: string;\n}\n\nclass BlockPicker extends FuzzySuggestModal<BlockChoice> {\n  constructor(app: App, private items: BlockChoice[], private onPick: (c: BlockChoice) => void) {\n    super(app);\n    this.setPlaceholder(\"Cite a passage from your sources\u2026\");\n  }\n  getItems(): BlockChoice[] {\n    return this.items;\n  }\n  getItemText(c: BlockChoice): string {\n    return `${c.citekey} \u2014 ${c.text.slice(0, 80)}`;\n  }\n  onChooseItem(c: BlockChoice): void {\n    this.onPick(c);\n  }\n}\n\nclass LocatorModal extends Modal {\n  private value = \"\";\n  constructor(app: App, private onSubmit: (locator: string) => void) {\n    super(app);\n  }\n  onOpen(): void {\n    this.titleEl.setText(\"Locator (page / section)\");\n    new Setting(this.contentEl).setName(\"Page\").addText((t) =>\n      t.setPlaceholder(\"p. 12\").onChange((v) => (this.value = v)),\n    );\n    new Setting(this.contentEl).addButton((b) =>\n      b\n        .setButtonText(\"Insert\")\n        .setCta()\n        .onClick(() => {\n          this.close();\n          this.onSubmit(this.value || \"n.p.\");\n        }),\n    );\n  }\n  onClose(): void {\n    this.contentEl.empty();\n  }\n}\n\nexport default class CiteEnginePlugin extends Plugin {\n  async onload(): Promise<void> {\n    this.addCommand({\n      id: \"stamp-source\",\n      name: \"Stamp source (assign citekey + block ids)\",\n      editorCallback: async (_editor: Editor, ctx: MarkdownFileInfo) => {\n        const file = ctx.file;\n        if (!file) return;\n        const text = await this.app.vault.read(file);\n        const { fm, body } = splitFrontmatter(text);\n        if (!fm.citekey) {\n          fm.citekey = generateCitekey({\n            author: String(fm.author ?? \"\"),\n            year: String(fm.year ?? \"\"),\n            title: String(fm.title ?? file.basename),\n          });\n        }\n        const { content } = stampNote(body);\n        await this.app.vault.modify(file, joinFrontmatter(fm, content));\n        new Notice(`Stamped as ${fm.citekey}`);\n      },\n    });\n\n    this.addCommand({\n      id: \"cite\",\n      name: \"Cite a passage\",\n      editorCallback: async (editor: Editor) => {\n        const reg = await buildRegistry(this.app);\n        const items: BlockChoice[] = [];\n        for (const [citekey, entry] of Object.entries(reg)) {\n          for (const [blockId, text] of Object.entries(entry.blocks)) {\n            items.push({ citekey, blockId, text });\n          }\n        }\n        if (items.length === 0) {\n          new Notice(\"No stamped sources yet. Run \u201CStamp source\u201D on a clipped note first.\");\n          return;\n        }\n        new BlockPicker(this.app, items, (choice) => {\n          new LocatorModal(this.app, (locator) => {\n            const cite = insertCitation(reg, {\n              citekey: choice.citekey,\n              blockId: choice.blockId,\n              locator,\n              quote: choice.text,\n            });\n            editor.replaceSelection(cite);\n          }).open();\n        }).open();\n      },\n    });\n\n    this.addCommand({\n      id: \"integrity-check\",\n      name: \"Integrity check (this note)\",\n      editorCallback: async (_editor: Editor, ctx: MarkdownFileInfo) => {\n        const file = ctx.file;\n        if (!file) return;\n        const reg = await buildRegistry(this.app);\n        const text = await this.app.vault.read(file);\n        const issues = checkIntegrity(text, reg);\n        if (issues.length === 0) {\n          new Notice(\"\u2713 All citations resolve. No drift.\");\n          return;\n        }\n        const lines = issues.map((i) => {\n          if (i.kind === \"drift\") return `DRIFT  ${i.citekey}#^${i.blockId}\\n  quoted:  ${i.expected}\\n  source:  ${i.actual}`;\n          if (i.kind === \"unresolved-block\") return `MISSING BLOCK  ${i.citekey}#^${i.blockId}`;\n          return `UNKNOWN SOURCE  ${i.citekey}`;\n        });\n        const report = `# Integrity report \u2014 ${file.basename}\\n\\n${lines.join(\"\\n\\n\")}\\n`;\n        await this.app.vault.create(`Integrity report \u2014 ${file.basename}.md`, report);\n        new Notice(`${issues.length} issue(s). See integrity report.`);\n      },\n    });\n  }\n}\n", "/**\n * cite-engine core \u2014 pure logic, no Obsidian imports.\n */\n\nexport interface SourceMeta {\n  citekey: string;\n  title: string;\n  author: string;\n  year: string;\n  url?: string;\n  clipped_at?: string;\n}\n\nexport interface SourceEntry {\n  meta: SourceMeta;\n  /** blockId -> current passage text */\n  blocks: Record<string, string>;\n}\n\n/** citekey -> source entry */\nexport type Registry = Record<string, SourceEntry>;\n\nexport interface Citation {\n  citekey: string;\n  blockId: string;\n  locator: string;\n  quote?: string;\n}\n\nexport type Issue =\n  | { kind: \"unresolved-source\"; citekey: string; raw: string }\n  | { kind: \"unresolved-block\"; citekey: string; blockId: string; raw: string }\n  | { kind: \"drift\"; citekey: string; blockId: string; expected: string; actual: string; raw: string };\n\nconst slug = (s: string): string =>\n  s\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\")\n    .split(\"-\")\n    .slice(0, 4)\n    .join(\"-\");\n\nconst surname = (author: string): string => {\n  const a = author.trim();\n  if (a.includes(\",\")) return slug(a.split(\",\")[0]);\n  const parts = a.split(/\\s+/);\n  return slug(parts[parts.length - 1] || a);\n};\n\n/** Stable, content-derived key: surname-year-titleslug. */\nexport function generateCitekey(meta: Pick<SourceMeta, \"author\" | \"year\" | \"title\">): string {\n  return [surname(meta.author), meta.year, slug(meta.title)].filter(Boolean).join(\"-\");\n}\n\nfunction newBlockId(existing: Set<string>): string {\n  let id: string;\n  do {\n    id = \"blk-\" + Math.random().toString(36).slice(2, 8);\n  } while (existing.has(id));\n  return id;\n}\n\nexport interface StampResult {\n  content: string;\n  blocks: Record<string, string>;\n}\n\nconst BLOCK_REF_RE = /\\s\\^([A-Za-z0-9-]+)\\s*$/;\n\n/**\n * Assign block ids to each non-empty paragraph of a source note body.\n * Idempotent; CRLF-tolerant (Windows files).\n */\nexport function stampNote(body: string): StampResult {\n  body = body.replace(/\\r\\n/g, \"\\n\");\n  const paras = body.split(/\\n{2,}/);\n  const existing = new Set<string>();\n  for (const p of paras) {\n    const m = p.match(BLOCK_REF_RE);\n    if (m) existing.add(m[1]);\n  }\n  const blocks: Record<string, string> = {};\n  const out = paras.map((p) => {\n    const trimmed = p.trim();\n    if (!trimmed) return p;\n    const m = p.match(BLOCK_REF_RE);\n    if (m) {\n      blocks[m[1]] = p.replace(BLOCK_REF_RE, \"\").trim();\n      return p;\n    }\n    const id = newBlockId(existing);\n    existing.add(id);\n    blocks[id] = trimmed;\n    return `${trimmed} ^${id}`;\n  });\n  return { content: out.join(\"\\n\\n\"), blocks };\n}\n\n/**\n * Produce a citation string. THROWS if the (citekey, blockId) is not already\n * in the registry \u2014 the structural no-fabrication guarantee.\n */\nexport function insertCitation(reg: Registry, c: Citation): string {\n  const entry = reg[c.citekey];\n  if (!entry) throw new Error(`unknown source: ${c.citekey}`);\n  if (!(c.blockId in entry.blocks)) throw new Error(`unknown block ${c.blockId} in ${c.citekey}`);\n  const ref = `[[${c.citekey}#^${c.blockId}|${c.locator}]]`;\n  return c.quote ? `\"${c.quote}\" ${ref}` : ref;\n}\n\nconst CITE_RE = /(?:\"([^\"]*)\"\\s*)?\\[\\[([^#\\]|]+)#\\^([A-Za-z0-9-]+)\\|([^\\]]*)\\]\\]/g;\n\n/** Extract every citation occurrence from a consuming note. */\nexport function parseCitations(text: string): Citation[] {\n  const out: Citation[] = [];\n  for (const m of text.matchAll(CITE_RE)) {\n    out.push({ quote: m[1], citekey: m[2], blockId: m[3], locator: m[4] });\n  }\n  return out;\n}\n\n/**\n * Scan a note against the registry. Flags citations whose source/block no\n * longer exists, and quotes that no longer match their referenced block.\n */\nexport function checkIntegrity(text: string, reg: Registry): Issue[] {\n  const issues: Issue[] = [];\n  for (const m of text.matchAll(CITE_RE)) {\n    const raw = m[0];\n    const quote = m[1];\n    const citekey = m[2];\n    const blockId = m[3];\n    const entry = reg[citekey];\n    if (!entry) {\n      issues.push({ kind: \"unresolved-source\", citekey, raw });\n      continue;\n    }\n    if (!(blockId in entry.blocks)) {\n      issues.push({ kind: \"unresolved-block\", citekey, blockId, raw });\n      continue;\n    }\n    if (quote !== undefined) {\n      const actual = entry.blocks[blockId];\n      if (quote.trim() !== actual.trim()) {\n        issues.push({ kind: \"drift\", citekey, blockId, expected: quote, actual, raw });\n      }\n    }\n  }\n  return issues;\n}\n"],
  "mappings": "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",
  "names": []
}
 +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/main.ts", "src/core.ts"],
  "sourcesContent": ["import {\n  App,\n  Editor,\n  FuzzySuggestModal,\n  Modal,\n  Notice,\n  Plugin,\n  Setting,\n  TFile,\n  parseYaml,\n  stringifyYaml,\n} from \"obsidian\";\nimport {\n  generateCitekey,\n  stampNote,\n  insertCitation,\n  checkIntegrity,\n  type Registry,\n} from \"./core\";\n\nconst FM_RE = /^---\\n([\\s\\S]*?)\\n---\\n?/;\n\nfunction splitFrontmatter(text: string): { fm: Record<string, unknown>; body: string } {\n  text = text.replace(/^\uFEFF/, \"\").replace(/\\r\\n/g, \"\\n\");\n  const m = text.match(FM_RE);\n  if (!m) return { fm: {}, body: text };\n  return { fm: (parseYaml(m[1]) as Record<string, unknown>) ?? {}, body: text.slice(m[0].length) };\n}\n\nfunction joinFrontmatter(fm: Record<string, unknown>, body: string): string {\n  return `---\\n${stringifyYaml(fm)}---\\n${body}`;\n}\n\n/** Build the closed-corpus registry from every note carrying a citekey. */\nasync function buildRegistry(app: App): Promise<Registry> {\n  const reg: Registry = {};\n  for (const file of app.vault.getMarkdownFiles()) {\n    const cache = app.metadataCache.getFileCache(file);\n    const citekey = cache?.frontmatter?.citekey as string | undefined;\n    if (!citekey) continue;\n    const text = await app.vault.cachedRead(file);\n    const { fm, body } = splitFrontmatter(text);\n    const { blocks } = stampNote(body);\n    reg[citekey] = {\n      meta: {\n        citekey,\n        title: String(fm.title ?? file.basename),\n        author: String(fm.author ?? \"\"),\n        year: String(fm.year ?? \"\"),\n        url: fm.url ? String(fm.url) : undefined,\n      },\n      blocks,\n    };\n  }\n  return reg;\n}\n\ninterface BlockChoice {\n  citekey: string;\n  blockId: string;\n  text: string;\n}\n\nclass BlockPicker extends FuzzySuggestModal<BlockChoice> {\n  constructor(app: App, private items: BlockChoice[], private onPick: (c: BlockChoice) => void) {\n    super(app);\n    this.setPlaceholder(\"Cite a passage from your sources\u2026\");\n  }\n  getItems(): BlockChoice[] {\n    return this.items;\n  }\n  getItemText(c: BlockChoice): string {\n    return `${c.citekey} \u2014 ${c.text.slice(0, 80)}`;\n  }\n  onChooseItem(c: BlockChoice): void {\n    this.onPick(c);\n  }\n}\n\nclass LocatorModal extends Modal {\n  private value = \"\";\n  constructor(app: App, private onSubmit: (locator: string) => void) {\n    super(app);\n  }\n  onOpen(): void {\n    this.titleEl.setText(\"Locator (page / section)\");\n    new Setting(this.contentEl).setName(\"Page\").addText((t) =>\n      t.setPlaceholder(\"p. 12\").onChange((v) => (this.value = v)),\n    );\n    new Setting(this.contentEl).addButton((b) =>\n      b\n        .setButtonText(\"Insert\")\n        .setCta()\n        .onClick(() => {\n          this.close();\n          this.onSubmit(this.value || \"n.p.\");\n        }),\n    );\n  }\n  onClose(): void {\n    this.contentEl.empty();\n  }\n}\n\nexport default class CiteEnginePlugin extends Plugin {\n  async onload(): Promise<void> {\n    this.addRibbonIcon(\"quote-glyph\", \"Cite Engine: cite a passage\", () => this.cite());\n\n    this.addCommand({\n      id: \"stamp-source\",\n      name: \"Stamp source (assign citekey + block ids)\",\n      callback: () => this.stampSource(),\n    });\n\n    this.addCommand({\n      id: \"cite\",\n      name: \"Cite a passage\",\n      callback: () => this.cite(),\n    });\n\n    this.addCommand({\n      id: \"integrity-check\",\n      name: \"Integrity check (this note)\",\n      callback: () => this.integrityCheck(),\n    });\n  }\n\n  /** Active markdown editor + its file, or null with a guiding notice. */\n  private activeNote(): { editor: Editor; file: TFile } | null {\n    const ae = this.app.workspace.activeEditor;\n    if (ae?.editor && ae.file) return { editor: ae.editor, file: ae.file };\n    new Notice(\"Open a markdown note first, then run this Cite Engine command.\");\n    return null;\n  }\n\n  private async stampSource(): Promise<void> {\n    const ctx = this.activeNote();\n    if (!ctx) return;\n    const { file } = ctx;\n    const text = await this.app.vault.read(file);\n    const { fm, body } = splitFrontmatter(text);\n    if (!fm.citekey) {\n      fm.citekey = generateCitekey({\n        author: String(fm.author ?? \"\"),\n        year: String(fm.year ?? \"\"),\n        title: String(fm.title ?? file.basename),\n      });\n    }\n    const { content } = stampNote(body);\n    await this.app.vault.modify(file, joinFrontmatter(fm, content));\n    new Notice(`Stamped as ${fm.citekey}`);\n  }\n\n  private async cite(): Promise<void> {\n    const ctx = this.activeNote();\n    if (!ctx) return;\n    const { editor } = ctx;\n    const reg = await buildRegistry(this.app);\n    const items: BlockChoice[] = [];\n    for (const [citekey, entry] of Object.entries(reg)) {\n      for (const [blockId, text] of Object.entries(entry.blocks)) {\n        items.push({ citekey, blockId, text });\n      }\n    }\n    if (items.length === 0) {\n      new Notice(\"No stamped sources yet. Run \u201CStamp source\u201D on a clipped note first.\");\n      return;\n    }\n    new BlockPicker(this.app, items, (choice) => {\n      new LocatorModal(this.app, (locator) => {\n        const cite = insertCitation(reg, {\n          citekey: choice.citekey,\n          blockId: choice.blockId,\n          locator,\n          quote: choice.text,\n        });\n        editor.replaceSelection(cite);\n      }).open();\n    }).open();\n  }\n\n  private async integrityCheck(): Promise<void> {\n    const ctx = this.activeNote();\n    if (!ctx) return;\n    const { file } = ctx;\n    const reg = await buildRegistry(this.app);\n    const text = await this.app.vault.read(file);\n    const issues = checkIntegrity(text, reg);\n    if (issues.length === 0) {\n      new Notice(\"\u2713 All citations resolve. No drift.\");\n      return;\n    }\n    const lines = issues.map((i) => {\n      if (i.kind === \"drift\") return `DRIFT  ${i.citekey}#^${i.blockId}\\n  quoted:  ${i.expected}\\n  source:  ${i.actual}`;\n      if (i.kind === \"unresolved-block\") return `MISSING BLOCK  ${i.citekey}#^${i.blockId}`;\n      return `UNKNOWN SOURCE  ${i.citekey}`;\n    });\n    const report = `# Integrity report \u2014 ${file.basename}\\n\\n${lines.join(\"\\n\\n\")}\\n`;\n    await this.app.vault.create(`Integrity report \u2014 ${file.basename}.md`, report);\n    new Notice(`${issues.length} issue(s). See integrity report.`);\n  }\n}\n", "/**\n * cite-engine core \u2014 pure logic, no Obsidian imports.\n */\n\nexport interface SourceMeta {\n  citekey: string;\n  title: string;\n  author: string;\n  year: string;\n  url?: string;\n  clipped_at?: string;\n}\n\nexport interface SourceEntry {\n  meta: SourceMeta;\n  /** blockId -> current passage text */\n  blocks: Record<string, string>;\n}\n\n/** citekey -> source entry */\nexport type Registry = Record<string, SourceEntry>;\n\nexport interface Citation {\n  citekey: string;\n  blockId: string;\n  locator: string;\n  quote?: string;\n}\n\nexport type Issue =\n  | { kind: \"unresolved-source\"; citekey: string; raw: string }\n  | { kind: \"unresolved-block\"; citekey: string; blockId: string; raw: string }\n  | { kind: \"drift\"; citekey: string; blockId: string; expected: string; actual: string; raw: string };\n\nconst slug = (s: string): string =>\n  s\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \"-\")\n    .replace(/^-+|-+$/g, \"\")\n    .split(\"-\")\n    .slice(0, 4)\n    .join(\"-\");\n\nconst surname = (author: string): string => {\n  const a = author.trim();\n  if (a.includes(\",\")) return slug(a.split(\",\")[0]);\n  const parts = a.split(/\\s+/);\n  return slug(parts[parts.length - 1] || a);\n};\n\n/** Stable, content-derived key: surname-year-titleslug. */\nexport function generateCitekey(meta: Pick<SourceMeta, \"author\" | \"year\" | \"title\">): string {\n  return [surname(meta.author), meta.year, slug(meta.title)].filter(Boolean).join(\"-\");\n}\n\nfunction newBlockId(existing: Set<string>): string {\n  let id: string;\n  do {\n    id = \"blk-\" + Math.random().toString(36).slice(2, 8);\n  } while (existing.has(id));\n  return id;\n}\n\nexport interface StampResult {\n  content: string;\n  blocks: Record<string, string>;\n}\n\nconst BLOCK_REF_RE = /\\s\\^([A-Za-z0-9-]+)\\s*$/;\n\n/**\n * Assign block ids to each non-empty paragraph of a source note body.\n * Idempotent; CRLF-tolerant (Windows files).\n */\nexport function stampNote(body: string): StampResult {\n  body = body.replace(/\\r\\n/g, \"\\n\");\n  const paras = body.split(/\\n{2,}/);\n  const existing = new Set<string>();\n  for (const p of paras) {\n    const m = p.match(BLOCK_REF_RE);\n    if (m) existing.add(m[1]);\n  }\n  const blocks: Record<string, string> = {};\n  const out = paras.map((p) => {\n    const trimmed = p.trim();\n    if (!trimmed) return p;\n    const m = p.match(BLOCK_REF_RE);\n    if (m) {\n      blocks[m[1]] = p.replace(BLOCK_REF_RE, \"\").trim();\n      return p;\n    }\n    const id = newBlockId(existing);\n    existing.add(id);\n    blocks[id] = trimmed;\n    return `${trimmed} ^${id}`;\n  });\n  return { content: out.join(\"\\n\\n\"), blocks };\n}\n\n/**\n * Produce a citation string. THROWS if the (citekey, blockId) is not already\n * in the registry \u2014 the structural no-fabrication guarantee.\n */\nexport function insertCitation(reg: Registry, c: Citation): string {\n  const entry = reg[c.citekey];\n  if (!entry) throw new Error(`unknown source: ${c.citekey}`);\n  if (!(c.blockId in entry.blocks)) throw new Error(`unknown block ${c.blockId} in ${c.citekey}`);\n  const ref = `[[${c.citekey}#^${c.blockId}|${c.locator}]]`;\n  return c.quote ? `\"${c.quote}\" ${ref}` : ref;\n}\n\nconst CITE_RE = /(?:\"([^\"]*)\"\\s*)?\\[\\[([^#\\]|]+)#\\^([A-Za-z0-9-]+)\\|([^\\]]*)\\]\\]/g;\n\n/** Extract every citation occurrence from a consuming note. */\nexport function parseCitations(text: string): Citation[] {\n  const out: Citation[] = [];\n  for (const m of text.matchAll(CITE_RE)) {\n    out.push({ quote: m[1], citekey: m[2], blockId: m[3], locator: m[4] });\n  }\n  return out;\n}\n\n/**\n * Scan a note against the registry. Flags citations whose source/block no\n * longer exists, and quotes that no longer match their referenced block.\n */\nexport function checkIntegrity(text: string, reg: Registry): Issue[] {\n  const issues: Issue[] = [];\n  for (const m of text.matchAll(CITE_RE)) {\n    const raw = m[0];\n    const quote = m[1];\n    const citekey = m[2];\n    const blockId = m[3];\n    const entry = reg[citekey];\n    if (!entry) {\n      issues.push({ kind: \"unresolved-source\", citekey, raw });\n      continue;\n    }\n    if (!(blockId in entry.blocks)) {\n      issues.push({ kind: \"unresolved-block\", citekey, blockId, raw });\n      continue;\n    }\n    if (quote !== undefined) {\n      const actual = entry.blocks[blockId];\n      if (quote.trim() !== actual.trim()) {\n        issues.push({ kind: \"drift\", citekey, blockId, expected: quote, actual, raw });\n      }\n    }\n  }\n  return issues;\n}\n"],
  "mappings": "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",
  "names": []
}
 diff --git a/manifest.json b/manifest.json index fb42cb1..88f0ef4 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "cite-engine", "name": "Cite Engine", - "version": "0.0.1", + "version": "0.0.2", "minAppVersion": "1.5.0", "description": "Drift-proof, closed-corpus citations via block refs. Cite only from your clipped sources — fabrication impossible by construction.", "author": "Nick", diff --git a/package.json b/package.json index 4b37697..9ee5d68 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "cite-engine", - "version": "0.0.1", + "version": "0.0.2", "description": "Drift-proof closed-corpus citations for Obsidian", "main": "main.js", "type": "module", diff --git a/src/main.ts b/src/main.ts index e45b8eb..7282ca5 100644 --- a/src/main.ts +++ b/src/main.ts @@ -2,11 +2,11 @@ import { App, Editor, FuzzySuggestModal, - MarkdownFileInfo, Modal, Notice, Plugin, Setting, + TFile, parseYaml, stringifyYaml, } from "obsidian"; @@ -104,78 +104,99 @@ class LocatorModal extends Modal { export default class CiteEnginePlugin extends Plugin { async onload(): Promise { + this.addRibbonIcon("quote-glyph", "Cite Engine: cite a passage", () => this.cite()); + this.addCommand({ id: "stamp-source", name: "Stamp source (assign citekey + block ids)", - editorCallback: async (_editor: Editor, ctx: MarkdownFileInfo) => { - const file = ctx.file; - if (!file) return; - const text = await this.app.vault.read(file); - const { fm, body } = splitFrontmatter(text); - if (!fm.citekey) { - fm.citekey = generateCitekey({ - author: String(fm.author ?? ""), - year: String(fm.year ?? ""), - title: String(fm.title ?? file.basename), - }); - } - const { content } = stampNote(body); - await this.app.vault.modify(file, joinFrontmatter(fm, content)); - new Notice(`Stamped as ${fm.citekey}`); - }, + callback: () => this.stampSource(), }); this.addCommand({ id: "cite", name: "Cite a passage", - editorCallback: async (editor: Editor) => { - const reg = await buildRegistry(this.app); - const items: BlockChoice[] = []; - for (const [citekey, entry] of Object.entries(reg)) { - for (const [blockId, text] of Object.entries(entry.blocks)) { - items.push({ citekey, blockId, text }); - } - } - if (items.length === 0) { - new Notice("No stamped sources yet. Run “Stamp source” on a clipped note first."); - return; - } - new BlockPicker(this.app, items, (choice) => { - new LocatorModal(this.app, (locator) => { - const cite = insertCitation(reg, { - citekey: choice.citekey, - blockId: choice.blockId, - locator, - quote: choice.text, - }); - editor.replaceSelection(cite); - }).open(); - }).open(); - }, + callback: () => this.cite(), }); this.addCommand({ id: "integrity-check", name: "Integrity check (this note)", - editorCallback: async (_editor: Editor, ctx: MarkdownFileInfo) => { - const file = ctx.file; - if (!file) return; - const reg = await buildRegistry(this.app); - const text = await this.app.vault.read(file); - const issues = checkIntegrity(text, reg); - if (issues.length === 0) { - new Notice("✓ All citations resolve. No drift."); - return; - } - const lines = issues.map((i) => { - if (i.kind === "drift") return `DRIFT ${i.citekey}#^${i.blockId}\n quoted: ${i.expected}\n source: ${i.actual}`; - if (i.kind === "unresolved-block") return `MISSING BLOCK ${i.citekey}#^${i.blockId}`; - return `UNKNOWN SOURCE ${i.citekey}`; - }); - const report = `# Integrity report — ${file.basename}\n\n${lines.join("\n\n")}\n`; - await this.app.vault.create(`Integrity report — ${file.basename}.md`, report); - new Notice(`${issues.length} issue(s). See integrity report.`); - }, + callback: () => this.integrityCheck(), }); } + + /** Active markdown editor + its file, or null with a guiding notice. */ + private activeNote(): { editor: Editor; file: TFile } | null { + const ae = this.app.workspace.activeEditor; + if (ae?.editor && ae.file) return { editor: ae.editor, file: ae.file }; + new Notice("Open a markdown note first, then run this Cite Engine command."); + return null; + } + + private async stampSource(): Promise { + const ctx = this.activeNote(); + if (!ctx) return; + const { file } = ctx; + const text = await this.app.vault.read(file); + const { fm, body } = splitFrontmatter(text); + if (!fm.citekey) { + fm.citekey = generateCitekey({ + author: String(fm.author ?? ""), + year: String(fm.year ?? ""), + title: String(fm.title ?? file.basename), + }); + } + const { content } = stampNote(body); + await this.app.vault.modify(file, joinFrontmatter(fm, content)); + new Notice(`Stamped as ${fm.citekey}`); + } + + private async cite(): Promise { + const ctx = this.activeNote(); + if (!ctx) return; + const { editor } = ctx; + const reg = await buildRegistry(this.app); + const items: BlockChoice[] = []; + for (const [citekey, entry] of Object.entries(reg)) { + for (const [blockId, text] of Object.entries(entry.blocks)) { + items.push({ citekey, blockId, text }); + } + } + if (items.length === 0) { + new Notice("No stamped sources yet. Run “Stamp source” on a clipped note first."); + return; + } + new BlockPicker(this.app, items, (choice) => { + new LocatorModal(this.app, (locator) => { + const cite = insertCitation(reg, { + citekey: choice.citekey, + blockId: choice.blockId, + locator, + quote: choice.text, + }); + editor.replaceSelection(cite); + }).open(); + }).open(); + } + + private async integrityCheck(): Promise { + const ctx = this.activeNote(); + if (!ctx) return; + const { file } = ctx; + const reg = await buildRegistry(this.app); + const text = await this.app.vault.read(file); + const issues = checkIntegrity(text, reg); + if (issues.length === 0) { + new Notice("✓ All citations resolve. No drift."); + return; + } + const lines = issues.map((i) => { + if (i.kind === "drift") return `DRIFT ${i.citekey}#^${i.blockId}\n quoted: ${i.expected}\n source: ${i.actual}`; + if (i.kind === "unresolved-block") return `MISSING BLOCK ${i.citekey}#^${i.blockId}`; + return `UNKNOWN SOURCE ${i.citekey}`; + }); + const report = `# Integrity report — ${file.basename}\n\n${lines.join("\n\n")}\n`; + await this.app.vault.create(`Integrity report — ${file.basename}.md`, report); + new Notice(`${issues.length} issue(s). See integrity report.`); + } } diff --git a/versions.json b/versions.json index 7e27ddb..9f66ed8 100644 --- a/versions.json +++ b/versions.json @@ -1,3 +1,4 @@ { - "0.0.1": "1.5.0" + "0.0.1": "1.5.0", + "0.0.2": "1.5.0" }