@theholocron/holocron-plugin-obsidian 0.0.0-stage → 5.0.0-alpha.399
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +43 -2
- package/dist/index.d.mts +72 -0
- package/dist/index.mjs +206 -0
- package/package.json +66 -3
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Newton Koumantzelis
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
CHANGED
|
@@ -1,3 +1,44 @@
|
|
|
1
|
-
#
|
|
1
|
+
# `@theholocron/holocron-plugin-obsidian`
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Obsidian plugin for [Holocron](../../cli/cli). Implements the `ideas` capability over a vault of Markdown notes, so
|
|
4
|
+
`holocron ideas sync` can read ideas without knowing where they are kept. It reads and writes files only: there is no
|
|
5
|
+
token and no network.
|
|
6
|
+
|
|
7
|
+
## Install
|
|
8
|
+
|
|
9
|
+
<!-- prettier-ignore -->
|
|
10
|
+
```bash
|
|
11
|
+
pnpm add -D @theholocron/holocron-plugin-obsidian
|
|
12
|
+
|
|
13
|
+
```
|
|
14
|
+
|
|
15
|
+
## Config
|
|
16
|
+
|
|
17
|
+
<!-- prettier-ignore -->
|
|
18
|
+
```ts
|
|
19
|
+
providers: {
|
|
20
|
+
ideas: ["obsidian", { vault: "The Holocron" }],
|
|
21
|
+
},
|
|
22
|
+
ideas: { states: { file: "in-progress" } },
|
|
23
|
+
```
|
|
24
|
+
|
|
25
|
+
### Options
|
|
26
|
+
|
|
27
|
+
| Option | Required | Description |
|
|
28
|
+
| ------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
29
|
+
| `vault` | No | The name of an Obsidian vault kept in iCloud Drive: the folder is `~/Library/Mobile Documents/iCloud~md~obsidian/Documents/<vault>`. One folder name, no `/` or `\`. |
|
|
30
|
+
| `dir` | No | The folder of notes. A leading `~` is the home folder. `HOLOCRON_IDEAS_DIR` overrides it (the path differs per machine). |
|
|
31
|
+
|
|
32
|
+
Most specific first: `HOLOCRON_IDEAS_DIR`, then `dir`, then `vault`. When both `dir` and `vault` are set, `dir` wins.
|
|
33
|
+
|
|
34
|
+
## What it does
|
|
35
|
+
|
|
36
|
+
- Lists every `.md` note under the folder except in folders whose name starts with `_` or `.`.
|
|
37
|
+
- Reads the `status:` and `issue:` properties, the title (first `#` heading, else the file name), the body and the
|
|
38
|
+
attachments (embedded files and `![[other note]]`; not web-address images or anything inside a code fence).
|
|
39
|
+
- `setStatus` and `markFiled` write `status:` and `issue:` and leave the rest of the file byte for byte, CRLF included.
|
|
40
|
+
- `retire` is not implemented: the CLI never deletes a note.
|
|
41
|
+
|
|
42
|
+
## Documentation
|
|
43
|
+
|
|
44
|
+
See the [plugin page](https://docs.theholocron.dev/holocron/plugins/obsidian/).
|
package/dist/index.d.mts
ADDED
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import { IdeaRecord, Ideas } from "@theholocron/cli";
|
|
2
|
+
/** One entry of a folder, as {@link IdeasIo.readDir} reports it. */
|
|
3
|
+
interface IdeasDirEntry {
|
|
4
|
+
/** The entry's name, without its folder. */
|
|
5
|
+
name: string;
|
|
6
|
+
/** Whether it is a folder. */
|
|
7
|
+
directory: boolean;
|
|
8
|
+
}
|
|
9
|
+
/** What the Obsidian provider reads and writes on disk, so a test can supply it without a disk. */
|
|
10
|
+
interface IdeasIo {
|
|
11
|
+
/** The entries of a folder, or `undefined` when it does not exist or cannot be read. */
|
|
12
|
+
readDir(path: string): IdeasDirEntry[] | undefined;
|
|
13
|
+
/** A file's text, or `undefined` when it cannot be read. */
|
|
14
|
+
read(path: string): string | undefined;
|
|
15
|
+
/** Replaces a file's text. Throws when the file cannot be written. */
|
|
16
|
+
write(path: string, text: string): void;
|
|
17
|
+
/** The home folder, for a `dir` that starts with `~`. */
|
|
18
|
+
home(): string;
|
|
19
|
+
}
|
|
20
|
+
/** Options for the Obsidian `ideas` provider. */
|
|
21
|
+
interface ObsidianIdeasOptions {
|
|
22
|
+
/**
|
|
23
|
+
* The folder of notes (an Obsidian vault). May start with `~` for the home folder. `HOLOCRON_IDEAS_DIR` overrides
|
|
24
|
+
* it, since the path differs per machine.
|
|
25
|
+
*/
|
|
26
|
+
dir?: string;
|
|
27
|
+
/**
|
|
28
|
+
* The name of an Obsidian vault kept in iCloud Drive, such as `"The Holocron"`: the folder is
|
|
29
|
+
* `~/Library/Mobile Documents/iCloud~md~obsidian/Documents/<vault>`. A single folder name, not a path. `dir` and
|
|
30
|
+
* `HOLOCRON_IDEAS_DIR` win over it when set.
|
|
31
|
+
*/
|
|
32
|
+
vault?: string;
|
|
33
|
+
/** The environment `HOLOCRON_IDEAS_DIR` is read from. Defaults to `process.env`. */
|
|
34
|
+
env?: Record<string, string | undefined>;
|
|
35
|
+
/** The disk. Defaults to the real one; a test supplies a fake. */
|
|
36
|
+
io?: IdeasIo;
|
|
37
|
+
}
|
|
38
|
+
/**
|
|
39
|
+
* The Obsidian implementation of the `ideas` capability: every Markdown note under the vault folder is an idea, its
|
|
40
|
+
* `status:` and `issue:` properties are its state and the issue it was filed as, and its key is its path relative to
|
|
41
|
+
* the folder. It reads and writes files only: no token, no network. It does not implement `retire`, because
|
|
42
|
+
* Obsidian's trash is reachable only through the app.
|
|
43
|
+
*/
|
|
44
|
+
export declare class ObsidianIdeas implements Ideas {
|
|
45
|
+
private readonly options;
|
|
46
|
+
private readonly io;
|
|
47
|
+
/** The capability this class provides, always `"ideas"`. */
|
|
48
|
+
readonly key: "ideas";
|
|
49
|
+
/** The provider name, `"obsidian"`. */
|
|
50
|
+
readonly providerName = "obsidian";
|
|
51
|
+
constructor(options: ObsidianIdeasOptions, io: IdeasIo);
|
|
52
|
+
/** Every note in the folder as an idea, sorted by path; a note that cannot be read comes back with an `error`. */
|
|
53
|
+
list(): Promise<IdeaRecord[]>;
|
|
54
|
+
/** Sets the note's `status:` property; the rest of the file stays as it was, byte for byte. */
|
|
55
|
+
setStatus(key: string, status: string): Promise<void>;
|
|
56
|
+
/** Sets the note's `issue:` property, read again first because a sync client may have changed the note. */
|
|
57
|
+
markFiled(key: string, issue: string): Promise<void>;
|
|
58
|
+
private dir;
|
|
59
|
+
private patch;
|
|
60
|
+
}
|
|
61
|
+
/** Options for the Obsidian plugin; the same as the `ideas` capability's. */
|
|
62
|
+
export type ObsidianPluginOptions = ObsidianIdeasOptions;
|
|
63
|
+
/** Builds the `ideas` capability from the plugin options. */
|
|
64
|
+
export declare function ideas(options: ObsidianPluginOptions): Ideas;
|
|
65
|
+
/** Creates the Obsidian plugin: the `ideas` capability. It has no probes, because there is nothing remote to poke. */
|
|
66
|
+
export declare function createPlugin(options?: ObsidianPluginOptions): {
|
|
67
|
+
name: string;
|
|
68
|
+
capabilities: {
|
|
69
|
+
ideas: () => Ideas;
|
|
70
|
+
};
|
|
71
|
+
};
|
|
72
|
+
export type { IdeasDirEntry, IdeasIo, ObsidianIdeasOptions };
|
package/dist/index.mjs
ADDED
|
@@ -0,0 +1,206 @@
|
|
|
1
|
+
import { basename, isAbsolute, join } from "node:path";
|
|
2
|
+
import { parseFrontmatter } from "@theholocron/astromech/repo-validation";
|
|
3
|
+
import { ConfigError } from "@theholocron/cli";
|
|
4
|
+
import { holocronEnv } from "@theholocron/env-utils/lookup";
|
|
5
|
+
import { readFileSync, readdirSync, writeFileSync } from "node:fs";
|
|
6
|
+
import { homedir } from "node:os";
|
|
7
|
+
// src/list-notes.ts
|
|
8
|
+
/**
|
|
9
|
+
* Every Markdown note under `dir`, as paths relative to it with `/` separators, sorted. A folder whose name starts
|
|
10
|
+
* with `_` or `.` (`.obsidian`, `.trash`, `_archive`) is not entered. `undefined` when `dir` itself cannot be read.
|
|
11
|
+
*/
|
|
12
|
+
function listNotes(io, dir) {
|
|
13
|
+
const top = io.readDir(dir);
|
|
14
|
+
if (!top) return void 0;
|
|
15
|
+
const found = [];
|
|
16
|
+
const walk = (relative, entries) => {
|
|
17
|
+
for (const entry of entries ?? []) {
|
|
18
|
+
const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
|
|
19
|
+
if (entry.directory) {
|
|
20
|
+
if (!/^[_.]/.test(entry.name)) walk(path, io.readDir(join(dir, path)));
|
|
21
|
+
} else if (entry.name.toLowerCase().endsWith(".md") && !entry.name.startsWith(".")) found.push(path);
|
|
22
|
+
}
|
|
23
|
+
};
|
|
24
|
+
walk("", top);
|
|
25
|
+
return found.sort();
|
|
26
|
+
}
|
|
27
|
+
// src/parse-note.ts
|
|
28
|
+
const FRONTMATTER = /^---\r?\n[\s\S]*?\r?\n---[ \t]*(?:\r?\n|$)/;
|
|
29
|
+
const FENCE = /^(```|~~~)[\s\S]*?^\1/gm;
|
|
30
|
+
const WEB_ADDRESS = /^[a-z][a-z0-9+.-]*:/i;
|
|
31
|
+
const unquote = (value) => value.replace(/^(["'])(.*)\1$/, "$2").trim();
|
|
32
|
+
/**
|
|
33
|
+
* Reads one note: its `status:` and `issue:` properties, its title, its text without the frontmatter and the files it
|
|
34
|
+
* embeds. The title is the first `#` heading, else `fileName` without `.md`. An embed is `![[x]]` (any) or ``
|
|
35
|
+
* where `x` is not an address with a scheme; embeds inside a code fence are text and do not count.
|
|
36
|
+
*/
|
|
37
|
+
function parseNote(text, fileName) {
|
|
38
|
+
const fields = parseFrontmatter(text.replace(/\r\n/g, "\n"));
|
|
39
|
+
const body = text.replace(FRONTMATTER, "");
|
|
40
|
+
const prose = body.replace(/\r/g, "").replace(FENCE, "");
|
|
41
|
+
const heading = /^#[ \t]+(.+?)[ \t]*$/m.exec(prose);
|
|
42
|
+
const wiki = [...prose.matchAll(/!\[\[[^\]]+\]\]/g)].map((m) => m[0]);
|
|
43
|
+
const links = [...prose.matchAll(/!\[[^\]]*\]\(([^)\s]+)[^)]*\)/g)].filter((m) => !WEB_ADDRESS.test(m[1])).map((m) => m[0]);
|
|
44
|
+
return {
|
|
45
|
+
status: unquote(fields?.get("status")?.value ?? ""),
|
|
46
|
+
issue: unquote(fields?.get("issue")?.value ?? ""),
|
|
47
|
+
title: heading?.[1] ?? fileName.replace(/\.md$/i, ""),
|
|
48
|
+
body,
|
|
49
|
+
attachments: [...wiki, ...links]
|
|
50
|
+
};
|
|
51
|
+
}
|
|
52
|
+
// src/resolve-ideas-dir.ts
|
|
53
|
+
/** Where Obsidian keeps every iCloud vault, relative to the home folder; a vault is a folder named for it inside. */
|
|
54
|
+
const ICLOUD_VAULTS_ROOT = "Library/Mobile Documents/iCloud~md~obsidian/Documents";
|
|
55
|
+
/** The config path the `vault` option is reported under in a `ConfigError`. */
|
|
56
|
+
const VAULT_PATH = "providers.ideas.vault";
|
|
57
|
+
/** Throws a `ConfigError` unless `vault` is a non-empty string naming one folder (no `/`, no `\`, not `.` or `..`). */
|
|
58
|
+
function checkVault(vault) {
|
|
59
|
+
if (typeof vault !== "string" || vault.trim() === "") throw new ConfigError(`${VAULT_PATH} must be a non-empty string`);
|
|
60
|
+
if (vault.includes("/") || vault.includes("\\") || vault === "." || vault === "..") throw new ConfigError(`${VAULT_PATH} must be a single folder name, not a path (got "${vault}")`);
|
|
61
|
+
}
|
|
62
|
+
/**
|
|
63
|
+
* The folder of idea notes, most specific first: `HOLOCRON_IDEAS_DIR` (then `IDEAS_DIR`), else the provider's `dir`,
|
|
64
|
+
* else the iCloud folder Obsidian keeps the `vault` in
|
|
65
|
+
* (`<home>/Library/Mobile Documents/iCloud~md~obsidian/Documents/<vault>`). A leading `~` in the variable or `dir` is
|
|
66
|
+
* the home folder. `undefined` when none names one. A `vault` that is not a single folder name is a `ConfigError`,
|
|
67
|
+
* even when `dir` or the variable wins.
|
|
68
|
+
*/
|
|
69
|
+
function resolveIdeasDir(dir, home, source, vault) {
|
|
70
|
+
if (vault !== void 0) checkVault(vault);
|
|
71
|
+
const chosen = holocronEnv(source).get("IDEAS_DIR") ?? dir;
|
|
72
|
+
if (chosen === void 0) return vault === void 0 ? void 0 : join(home, ICLOUD_VAULTS_ROOT, vault);
|
|
73
|
+
if (chosen === "~") return home;
|
|
74
|
+
return chosen.startsWith("~/") ? join(home, chosen.slice(2)) : chosen;
|
|
75
|
+
}
|
|
76
|
+
// src/write-property.ts
|
|
77
|
+
const BLOCK = /^---(\r?\n)([\s\S]*?)(\r?\n)---/;
|
|
78
|
+
/**
|
|
79
|
+
* The note's text with `<name>: <value>` in its frontmatter: an existing `<name>:` line (blank or not) is replaced in
|
|
80
|
+
* place, else a line is added at the end of the block. Everything else, including line endings and the body, is left
|
|
81
|
+
* byte for byte. A note with no frontmatter is returned unchanged (such a note has no `status:`, so it is never filed).
|
|
82
|
+
* `name` is a plain property name (`status`, `issue`).
|
|
83
|
+
*/
|
|
84
|
+
function writeProperty(text, name, value) {
|
|
85
|
+
const match = BLOCK.exec(text);
|
|
86
|
+
if (!match) return text;
|
|
87
|
+
const [whole, open, inner, close] = match;
|
|
88
|
+
const lines = inner.split(/\r?\n/);
|
|
89
|
+
const separators = inner.match(/\r?\n/g) ?? [];
|
|
90
|
+
const line = `${name}: ${value}`;
|
|
91
|
+
const at = lines.findIndex((l) => l.startsWith(`${name}:`));
|
|
92
|
+
const next = at === -1 ? [...lines, line] : lines.map((l, i) => i === at ? line : l);
|
|
93
|
+
let rebuilt = next[0];
|
|
94
|
+
next.slice(1).forEach((l, i) => {
|
|
95
|
+
rebuilt += (separators[i] ?? close) + l;
|
|
96
|
+
});
|
|
97
|
+
return `---${open}${rebuilt}${close}---${text.slice(whole.length)}`;
|
|
98
|
+
}
|
|
99
|
+
// src/capabilities/ideas.ts
|
|
100
|
+
/**
|
|
101
|
+
* The Obsidian implementation of the `ideas` capability: every Markdown note under the vault folder is an idea, its
|
|
102
|
+
* `status:` and `issue:` properties are its state and the issue it was filed as, and its key is its path relative to
|
|
103
|
+
* the folder. It reads and writes files only: no token, no network. It does not implement `retire`, because
|
|
104
|
+
* Obsidian's trash is reachable only through the app.
|
|
105
|
+
*/
|
|
106
|
+
var ObsidianIdeas = class {
|
|
107
|
+
options;
|
|
108
|
+
io;
|
|
109
|
+
/** The capability this class provides, always `"ideas"`. */
|
|
110
|
+
key = "ideas";
|
|
111
|
+
/** The provider name, `"obsidian"`. */
|
|
112
|
+
providerName = "obsidian";
|
|
113
|
+
constructor(options, io) {
|
|
114
|
+
this.options = options;
|
|
115
|
+
this.io = io;
|
|
116
|
+
}
|
|
117
|
+
/** Every note in the folder as an idea, sorted by path; a note that cannot be read comes back with an `error`. */
|
|
118
|
+
async list() {
|
|
119
|
+
const dir = this.dir();
|
|
120
|
+
const paths = listNotes(this.io, dir);
|
|
121
|
+
if (!paths) throw new Error(`the notes folder does not exist or cannot be read: ${dir}`);
|
|
122
|
+
return paths.map((path) => {
|
|
123
|
+
const text = this.io.read(join(dir, path));
|
|
124
|
+
const fileName = basename(path);
|
|
125
|
+
if (text === void 0) return {
|
|
126
|
+
key: path,
|
|
127
|
+
title: fileName,
|
|
128
|
+
body: "",
|
|
129
|
+
status: "",
|
|
130
|
+
attachments: [],
|
|
131
|
+
error: "cannot be read"
|
|
132
|
+
};
|
|
133
|
+
const note = parseNote(text, fileName);
|
|
134
|
+
return {
|
|
135
|
+
key: path,
|
|
136
|
+
title: note.title,
|
|
137
|
+
body: note.body,
|
|
138
|
+
status: note.status,
|
|
139
|
+
...note.issue === "" ? {} : { issue: note.issue },
|
|
140
|
+
attachments: note.attachments
|
|
141
|
+
};
|
|
142
|
+
});
|
|
143
|
+
}
|
|
144
|
+
/** Sets the note's `status:` property; the rest of the file stays as it was, byte for byte. */
|
|
145
|
+
async setStatus(key, status) {
|
|
146
|
+
this.patch(key, "status", status);
|
|
147
|
+
}
|
|
148
|
+
/** Sets the note's `issue:` property, read again first because a sync client may have changed the note. */
|
|
149
|
+
async markFiled(key, issue) {
|
|
150
|
+
this.patch(key, "issue", issue);
|
|
151
|
+
}
|
|
152
|
+
dir() {
|
|
153
|
+
const dir = resolveIdeasDir(this.options.dir, this.io.home(), this.options.env, this.options.vault);
|
|
154
|
+
if (!dir) throw new Error("no notes folder: set `vault` or `dir` on the `ideas` provider (`providers.ideas: [\"obsidian\", { vault }]`) or HOLOCRON_IDEAS_DIR");
|
|
155
|
+
return dir;
|
|
156
|
+
}
|
|
157
|
+
patch(key, name, value) {
|
|
158
|
+
if (isAbsolute(key) || key.split("/").includes("..")) throw new Error(`"${key}" is not a path inside the notes folder`);
|
|
159
|
+
const path = join(this.dir(), key);
|
|
160
|
+
const text = this.io.read(path);
|
|
161
|
+
if (text === void 0) throw new Error("the note can no longer be read");
|
|
162
|
+
const next = writeProperty(text, name, value);
|
|
163
|
+
if (parseNote(next, basename(key))[name] !== value) throw new Error(`the note has no frontmatter to hold \`${name}:\``);
|
|
164
|
+
if (next !== text) this.io.write(path, next);
|
|
165
|
+
}
|
|
166
|
+
};
|
|
167
|
+
// src/real-ideas-io.ts
|
|
168
|
+
/** The `ideas sync` inputs from the real filesystem. */
|
|
169
|
+
function realIdeasIo() {
|
|
170
|
+
/* v8 ignore start -- reads the real filesystem; the command is tested with an injected io */
|
|
171
|
+
return {
|
|
172
|
+
readDir: (path) => {
|
|
173
|
+
try {
|
|
174
|
+
return readdirSync(path, { withFileTypes: true }).map((e) => ({
|
|
175
|
+
name: e.name,
|
|
176
|
+
directory: e.isDirectory()
|
|
177
|
+
}));
|
|
178
|
+
} catch {
|
|
179
|
+
return;
|
|
180
|
+
}
|
|
181
|
+
},
|
|
182
|
+
read: (path) => {
|
|
183
|
+
try {
|
|
184
|
+
return readFileSync(path, "utf8");
|
|
185
|
+
} catch {
|
|
186
|
+
return;
|
|
187
|
+
}
|
|
188
|
+
},
|
|
189
|
+
write: (path, text) => writeFileSync(path, text, "utf8"),
|
|
190
|
+
home: () => homedir()
|
|
191
|
+
};
|
|
192
|
+
/* v8 ignore stop */
|
|
193
|
+
}
|
|
194
|
+
// src/index.ts
|
|
195
|
+
/** Builds the `ideas` capability from the plugin options. */
|
|
196
|
+
function ideas(options) {
|
|
197
|
+
return new ObsidianIdeas(options, options.io ?? realIdeasIo());
|
|
198
|
+
}
|
|
199
|
+
/** Creates the Obsidian plugin: the `ideas` capability. It has no probes, because there is nothing remote to poke. */
|
|
200
|
+
function createPlugin(options = {}) {
|
|
201
|
+
return {
|
|
202
|
+
name: "@theholocron/holocron-plugin-obsidian",
|
|
203
|
+
capabilities: { ideas: () => ideas(options) }
|
|
204
|
+
};
|
|
205
|
+
}
|
|
206
|
+
export { ObsidianIdeas, createPlugin, ideas };
|
package/package.json
CHANGED
|
@@ -1,6 +1,69 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@theholocron/holocron-plugin-obsidian",
|
|
3
|
-
"version": "
|
|
4
|
-
"
|
|
5
|
-
"
|
|
3
|
+
"version": "5.0.0-alpha.399",
|
|
4
|
+
"description": "Holocron plugin for Obsidian. Implements the ideas capability over a vault of Markdown notes.",
|
|
5
|
+
"keywords": [
|
|
6
|
+
"holocron",
|
|
7
|
+
"ideas",
|
|
8
|
+
"obsidian",
|
|
9
|
+
"plugin"
|
|
10
|
+
],
|
|
11
|
+
"homepage": "https://docs.theholocron.dev/holocron/plugins/obsidian/",
|
|
12
|
+
"bugs": "https://github.com/theholocron/holocron/issues",
|
|
13
|
+
"repository": {
|
|
14
|
+
"type": "git",
|
|
15
|
+
"url": "git+https://github.com/theholocron/holocron.git",
|
|
16
|
+
"directory": "plugins/holocron-plugin-obsidian"
|
|
17
|
+
},
|
|
18
|
+
"license": "MIT",
|
|
19
|
+
"author": "Newton Koumantzelis",
|
|
20
|
+
"sideEffects": false,
|
|
21
|
+
"type": "module",
|
|
22
|
+
"exports": {
|
|
23
|
+
".": {
|
|
24
|
+
"types": "./dist/index.d.mts",
|
|
25
|
+
"import": "./dist/index.mjs",
|
|
26
|
+
"default": "./dist/index.mjs"
|
|
27
|
+
}
|
|
28
|
+
},
|
|
29
|
+
"files": [
|
|
30
|
+
"dist"
|
|
31
|
+
],
|
|
32
|
+
"dependencies": {
|
|
33
|
+
"@theholocron/astromech": "^5.0.0-alpha.399",
|
|
34
|
+
"@theholocron/env-utils": "^1.17.0-alpha.3"
|
|
35
|
+
},
|
|
36
|
+
"devDependencies": {
|
|
37
|
+
"@types/node": "^26",
|
|
38
|
+
"@vitest/coverage-v8": "^5.1.0",
|
|
39
|
+
"@vitest/eslint-plugin": "^1.6.28",
|
|
40
|
+
"eslint": "^10.14.0",
|
|
41
|
+
"eslint-plugin-n": "^18.5.0",
|
|
42
|
+
"globals": "^17.14.0",
|
|
43
|
+
"tsdown": "^0.23.5",
|
|
44
|
+
"tsx": "4.23.15",
|
|
45
|
+
"typescript": "^5.9.3",
|
|
46
|
+
"vitest": "^5.1.0",
|
|
47
|
+
"@theholocron/cli": "5.0.0-alpha.399",
|
|
48
|
+
"@theholocron/eslint-config": "^8.9.0-alpha.15",
|
|
49
|
+
"@theholocron/tsconfig": "^8.9.0-alpha.15",
|
|
50
|
+
"@theholocron/vitest-config": "^8.9.0-alpha.15",
|
|
51
|
+
"@theholocron/tsdown-config": "^8.9.0-alpha.15"
|
|
52
|
+
},
|
|
53
|
+
"peerDependencies": {
|
|
54
|
+
"@theholocron/cli": "5.0.0-alpha.399"
|
|
55
|
+
},
|
|
56
|
+
"engines": {
|
|
57
|
+
"node": ">=22"
|
|
58
|
+
},
|
|
59
|
+
"publishConfig": {
|
|
60
|
+
"access": "public"
|
|
61
|
+
},
|
|
62
|
+
"scripts": {
|
|
63
|
+
"build": "tsdown",
|
|
64
|
+
"lint:code": "eslint .",
|
|
65
|
+
"test:unit": "vitest run --coverage",
|
|
66
|
+
"test:watch": "vitest",
|
|
67
|
+
"typecheck": "tsc --noEmit"
|
|
68
|
+
}
|
|
6
69
|
}
|