knowmind 0.3.9 → 0.4.0
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/CHANGELOG.md +32 -0
- package/README.md +19 -0
- package/bin/knowmind.js +5 -1
- package/package.json +3 -2
- package/src/client.js +3 -0
- package/src/okf.js +186 -0
- package/src/sync.js +77 -5
- package/src/tools-fallback.json +5 -5
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,37 @@
|
|
|
1
1
|
# Knowmind CLI — Änderungen
|
|
2
2
|
|
|
3
|
+
## 0.4.0 (2026-10-16)
|
|
4
|
+
|
|
5
|
+
**`knowmind sync` übernimmt Wissen im Open Knowledge Format**
|
|
6
|
+
|
|
7
|
+
- Liegt in einem Ordner Wissen im Open Knowledge Format (OKF 0.1 oder 0.2),
|
|
8
|
+
etwa im Ordner `openwiki/`, den OpenWiki in einem Repository anlegt, liest
|
|
9
|
+
`knowmind sync` den Kopf jeder Seite mit.
|
|
10
|
+
- Jeder Treffer der Suche trägt danach den Status der Seite (`status`, ohne
|
|
11
|
+
Angabe `stable`), die Vertrauensstufe nach OKF (`trust`: `unverified`,
|
|
12
|
+
`machine-confirmed` oder `human-reviewed`, also ungeprüft, maschinell
|
|
13
|
+
bestätigt oder von einem Menschen geprüft) und die Zahl der Quellen. Soweit
|
|
14
|
+
die Seite es angibt, kommen hinzu: wer oder was die Seite erzeugt hat
|
|
15
|
+
(`generated`), die letzten fünf Prüfungen (`verified`), der Zeitpunkt, ab dem
|
|
16
|
+
die Seite als veraltet gilt (`stale_after`), und die ersten zehn Quellen
|
|
17
|
+
(`sources`). Der vollständige Kopf bleibt Teil des Dokuments.
|
|
18
|
+
- Der Zeitpunkt der letzten inhaltlichen Änderung (`generated.at`, bei OKF 0.1
|
|
19
|
+
`timestamp`) gilt als Beginn der Gültigkeit. `knowmind_recall_at_time`
|
|
20
|
+
zeigt die Seite deshalb erst ab diesem Zeitpunkt.
|
|
21
|
+
- Belege unter `.claims/` werden gezählt, und knowmind vermerkt, ob sie zur
|
|
22
|
+
aktuellen Fassung der Seite gehören. Ändern sich nur die Belege, lädt
|
|
23
|
+
`knowmind sync` die Seite erneut hoch.
|
|
24
|
+
- In einem solchen Ordner übernimmt `knowmind sync` die Verzeichnislisten
|
|
25
|
+
`index.md` und die Verläufe `log.md` nicht als Dokumente, ebenso wenig den
|
|
26
|
+
Arbeitsauftrag `INSTRUCTIONS.md` an der Wurzel eines OpenWiki-Ordners.
|
|
27
|
+
- Erkannt wird ein solcher Ordner an `okf_version` in der `index.md` an seiner
|
|
28
|
+
Wurzel oder an den Verwaltungsdateien von OpenWiki. Findet `knowmind sync`
|
|
29
|
+
keine solche Kennung, behandelt es den angegebenen Ordner mit `--okf`
|
|
30
|
+
trotzdem als OKF-Bündel.
|
|
31
|
+
- Die mitgelieferte Werkzeugliste trägt den Stand des Servers vom 16. Oktober.
|
|
32
|
+
Die Beschreibung von `hops` bei `knowmind_recall_memories` sagt jetzt, dass
|
|
33
|
+
der Wert den Abruf derzeit nicht verändert.
|
|
34
|
+
|
|
3
35
|
## 0.3.9 (2026-10-10)
|
|
4
36
|
|
|
5
37
|
**`knowmind sync` hält umbenannte Dateien zusammen**
|
package/README.md
CHANGED
|
@@ -84,8 +84,27 @@ npx -y knowmind upload notes.md --title "Meeting notes 2026-05-12"
|
|
|
84
84
|
npx -y knowmind stats
|
|
85
85
|
npx -y knowmind health
|
|
86
86
|
npx -y knowmind status --line # one-line status for your AI tool's statusline
|
|
87
|
+
npx -y knowmind sync ./openwiki # pages in Open Knowledge Format keep their review data
|
|
87
88
|
```
|
|
88
89
|
|
|
90
|
+
### Knowledge in Open Knowledge Format
|
|
91
|
+
|
|
92
|
+
`knowmind sync` reads folders in the Open Knowledge Format (OKF 0.1 and 0.2),
|
|
93
|
+
such as the `openwiki/` folder that OpenWiki creates in a repository.
|
|
94
|
+
|
|
95
|
+
Every search hit then carries the page's `status` (`stable` if the page sets
|
|
96
|
+
none), its trust tier as defined by OKF (`trust`: `unverified`,
|
|
97
|
+
`machine-confirmed` or `human-reviewed`) and how many sources it lists. If the
|
|
98
|
+
page provides them, the hit also carries who or what generated the page
|
|
99
|
+
(`generated`), its last five verifications (`verified`), the time after which
|
|
100
|
+
it counts as stale (`stale_after`) and its first ten sources (`sources`). The
|
|
101
|
+
full header stays part of the document.
|
|
102
|
+
|
|
103
|
+
Inside a bundle, directory listings (`index.md`) and logs (`log.md`) are not
|
|
104
|
+
imported. knowmind recognizes a bundle by `okf_version` in its root `index.md` or by the
|
|
105
|
+
files OpenWiki keeps there. If it finds neither, `--okf` treats the folder you
|
|
106
|
+
sync as a bundle.
|
|
107
|
+
|
|
89
108
|
## Available Tools
|
|
90
109
|
|
|
91
110
|
Thirteen tools over MCP. Every one works against your own workspace; the server
|
package/bin/knowmind.js
CHANGED
|
@@ -61,9 +61,12 @@ Befehle:
|
|
|
61
61
|
Hybrid-Recall gegen den Tenant-Korpus
|
|
62
62
|
knowmind upload <file> [--title "..."]
|
|
63
63
|
Markdown-/Text-Datei indexieren (stdin: knowmind upload -)
|
|
64
|
-
knowmind sync <dir> [--ext .md,.txt] [--verbose] [--title-from-content]
|
|
64
|
+
knowmind sync <dir> [--ext .md,.txt] [--verbose] [--title-from-content] [--okf]
|
|
65
65
|
Ordner mit dem Korpus abgleichen. Idempotent über
|
|
66
66
|
Content-Hash, Manifest in <dir>/.knowmind-manifest.json.
|
|
67
|
+
Seiten im Open Knowledge Format (z. B. openwiki/) behalten
|
|
68
|
+
Herkunft, Prüfstand und Verfallsdatum; --okf behandelt
|
|
69
|
+
den Ordner als Bündel, auch ohne okf_version.
|
|
67
70
|
knowmind stats Memory- und Edge-Counter des Tenants
|
|
68
71
|
knowmind health Health-Check der Plattform
|
|
69
72
|
knowmind status [--line]
|
|
@@ -218,6 +221,7 @@ async function runSync() {
|
|
|
218
221
|
extensions: extFlag ? extFlag.split(",").map((e) => (e.startsWith(".") ? e : `.${e}`)) : undefined,
|
|
219
222
|
verbose: args.includes("--verbose"),
|
|
220
223
|
titleFromContent: args.includes("--title-from-content"),
|
|
224
|
+
okf: args.includes("--okf"),
|
|
221
225
|
};
|
|
222
226
|
const result = await syncDirectory(dir, options);
|
|
223
227
|
if (result.failed > 0) process.exitCode = 3;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "knowmind",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.4.0",
|
|
4
4
|
"mcpName": "io.github.Schubeler-Consulting/knowmind",
|
|
5
5
|
"description": "Knowmind — das Agentengehirn aus Deutschland: CLI + MCP-Server (Langzeitgedächtnis & Wissensgraph für Ihre KI, Server in Deutschland).",
|
|
6
6
|
"type": "module",
|
|
@@ -39,7 +39,8 @@
|
|
|
39
39
|
"tools:abgleich": "node scripts/tools-abgleich.mjs"
|
|
40
40
|
},
|
|
41
41
|
"dependencies": {
|
|
42
|
-
"@huggingface/transformers": "^3.5.0"
|
|
42
|
+
"@huggingface/transformers": "^3.5.0",
|
|
43
|
+
"yaml": "^2.9.1"
|
|
43
44
|
},
|
|
44
45
|
"overrides": {
|
|
45
46
|
"global-agent": "^4.1.3"
|
package/src/client.js
CHANGED
|
@@ -121,6 +121,9 @@ export async function uploadDocument(title, content, opts = {}) {
|
|
|
121
121
|
// Quelldatei relativ zum Ordner: Der Server findet darüber die Fassung
|
|
122
122
|
// derselben Datei, auch wenn sich der Titel geändert hat.
|
|
123
123
|
if (opts.sourcePath) body.sourcePath = opts.sourcePath;
|
|
124
|
+
// Herkunft und Prüfstand einer OKF-Seite (okf.js): stehen danach an jedem
|
|
125
|
+
// Abschnitt, auch wenn der Server die Abschnitte selbst bildet.
|
|
126
|
+
if (opts.metadata) body.metadata = opts.metadata;
|
|
124
127
|
|
|
125
128
|
const r = await fetch(`${apiUrl}/api/documents`, {
|
|
126
129
|
method: "POST",
|
package/src/okf.js
ADDED
|
@@ -0,0 +1,186 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Bündel im Open Knowledge Format (OKF 0.1 und 0.2) für `knowmind sync`.
|
|
3
|
+
*
|
|
4
|
+
* Ein OKF-Bündel ist ein Ordner mit Markdown-Seiten, deren YAML-Kopf sagt,
|
|
5
|
+
* woher eine Seite stammt (`sources`), wer sie geschrieben und wer sie geprüft
|
|
6
|
+
* hat (`generated`, `verified`), ob sie noch gilt (`status`, `stale_after`).
|
|
7
|
+
* So schreibt etwa OpenWiki das Verzeichnis openwiki/ eines Repos, dazu unter
|
|
8
|
+
* `.claims/` je Seite die belegten Aussagen. Spezifikation:
|
|
9
|
+
* https://github.com/GoogleCloudPlatform/open-knowledge-format
|
|
10
|
+
* (SPEC.md, Version 0.2).
|
|
11
|
+
*
|
|
12
|
+
* Dieses Modul erkennt ein Bündel und bildet den Kopf einer Seite auf die
|
|
13
|
+
* Angaben ab, die knowmind an jedem Abschnitt des Dokuments führt:
|
|
14
|
+
*
|
|
15
|
+
* - `metadata.okf`: Typ, Status, Vertrauensstufe (§5.3), Prüfungen,
|
|
16
|
+
* Erzeugung, Verfallsdatum, die ersten Quellen und der Stand der Belege.
|
|
17
|
+
* Kurz gehalten, weil die Angaben an jedem Treffer des Abrufs stehen und
|
|
18
|
+
* damit im Kontext des Agenten landen; den vollständigen Kopf trägt das
|
|
19
|
+
* Dokument selbst.
|
|
20
|
+
* - `metadata.valid_from`: der Zeitpunkt der letzten inhaltlichen Änderung
|
|
21
|
+
* (`generated.at`, bei OKF 0.1 `timestamp`). Der Abruf zu einem Zeitpunkt
|
|
22
|
+
* wertet ihn aus.
|
|
23
|
+
*/
|
|
24
|
+
import { existsSync, readFileSync } from "node:fs";
|
|
25
|
+
import { join } from "node:path";
|
|
26
|
+
import { createHash } from "node:crypto";
|
|
27
|
+
import { parse } from "yaml";
|
|
28
|
+
|
|
29
|
+
/** Dateien mit festgelegter Bedeutung (§3.1): Verzeichnisliste und Verlauf, keine Seiten. */
|
|
30
|
+
export const RESERVIERT = new Set(["index.md", "log.md"]);
|
|
31
|
+
|
|
32
|
+
const HOECHSTZAHL_QUELLEN = 10;
|
|
33
|
+
const HOECHSTZAHL_VERIFIZIERT = 5;
|
|
34
|
+
|
|
35
|
+
/** YAML-Kopf einer Markdown-Datei als Objekt, sonst null. */
|
|
36
|
+
export function kopfLesen(inhalt) {
|
|
37
|
+
const m = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(inhalt);
|
|
38
|
+
if (!m) return null;
|
|
39
|
+
try {
|
|
40
|
+
const daten = parse(m[1]);
|
|
41
|
+
return daten && typeof daten === "object" && !Array.isArray(daten) ? daten : null;
|
|
42
|
+
} catch {
|
|
43
|
+
return null;
|
|
44
|
+
}
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/**
|
|
48
|
+
* Ist `ordner` die Wurzel eines Bündels? Ein Bündel nennt seine Fassung im
|
|
49
|
+
* Kopf der `index.md` an der Wurzel (`okf_version`, §12). OpenWiki-Verzeichnisse
|
|
50
|
+
* erkennt man zusätzlich an `.last-update.json` und `.page-manifest.json`.
|
|
51
|
+
* Rückgabe `{ version, openwiki }` oder null.
|
|
52
|
+
*/
|
|
53
|
+
export function buendelWurzel(ordner) {
|
|
54
|
+
const index = join(ordner, "index.md");
|
|
55
|
+
let version = null;
|
|
56
|
+
if (existsSync(index)) {
|
|
57
|
+
const kopf = kopfLesen(readFileSync(index, "utf-8"));
|
|
58
|
+
if (kopf?.okf_version != null) version = String(kopf.okf_version);
|
|
59
|
+
}
|
|
60
|
+
const openwiki = existsSync(join(ordner, ".last-update.json")) && existsSync(join(ordner, ".page-manifest.json"));
|
|
61
|
+
if (!version && !openwiki) return null;
|
|
62
|
+
return { version: version ?? "unbekannt", openwiki };
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
/** Zeitpunkt als ISO 8601 in UTC, sonst null. */
|
|
66
|
+
export function zeitpunkt(wert) {
|
|
67
|
+
if (wert == null || wert === "") return null;
|
|
68
|
+
const ms = wert instanceof Date ? wert.getTime() : Date.parse(String(wert));
|
|
69
|
+
return Number.isNaN(ms) ? null : new Date(ms).toISOString();
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/** `verified` als Liste (§5.2: eine einzelne Angabe zählt als Liste mit einem Eintrag). */
|
|
73
|
+
export function verifiziert(verified) {
|
|
74
|
+
if (verified == null) return [];
|
|
75
|
+
const liste = Array.isArray(verified) ? verified : [verified];
|
|
76
|
+
return liste
|
|
77
|
+
.filter((v) => v && typeof v === "object" && typeof v.by === "string" && v.by.trim())
|
|
78
|
+
.map((v) => ({ by: v.by.trim(), at: zeitpunkt(v.at) }));
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
/** Vertrauensstufe nach §5.3: ungeprüft, maschinell bestätigt, von einem Menschen geprüft. */
|
|
82
|
+
export function vertrauensstufe(liste) {
|
|
83
|
+
if (liste.length === 0) return "unverified";
|
|
84
|
+
return liste.some((v) => v.by.startsWith("human:")) ? "human-reviewed" : "machine-confirmed";
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
/** Prüfsumme der Seite in der Schreibweise von OpenWiki (`pageVersion`). */
|
|
88
|
+
export function seitenFassung(inhalt) {
|
|
89
|
+
return "sha256:" + createHash("sha256").update(inhalt, "utf-8").digest("hex");
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
/**
|
|
93
|
+
* Belege einer Seite aus `.claims/<Seite>.json` (OpenWiki). Rückgabe
|
|
94
|
+
* `{ roh, daten }` oder null; `roh` geht in die Änderungserkennung ein, damit
|
|
95
|
+
* neue Belege zu einer unveränderten Seite ankommen.
|
|
96
|
+
*/
|
|
97
|
+
export function belegeLesen(wurzel, konzept) {
|
|
98
|
+
const pfad = join(wurzel, ".claims", `${konzept}.json`);
|
|
99
|
+
if (!existsSync(pfad)) return null;
|
|
100
|
+
const roh = readFileSync(pfad, "utf-8");
|
|
101
|
+
try {
|
|
102
|
+
return { roh, daten: JSON.parse(roh) };
|
|
103
|
+
} catch {
|
|
104
|
+
return { roh, daten: null };
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/**
|
|
109
|
+
* Commit, den OpenWiki für eine Seite dokumentiert hat (`.page-manifest.json`,
|
|
110
|
+
* Schlüssel ist der Pfad ab Repo-Wurzel). Sonst null.
|
|
111
|
+
*/
|
|
112
|
+
export function seitenCommit(seiten, rel) {
|
|
113
|
+
if (!seiten || typeof seiten !== "object") return null;
|
|
114
|
+
for (const [pfad, eintrag] of Object.entries(seiten)) {
|
|
115
|
+
if ((pfad === rel || pfad.endsWith("/" + rel)) && typeof eintrag?.gitHead === "string") return eintrag.gitHead;
|
|
116
|
+
}
|
|
117
|
+
return null;
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
/** Die Seitenliste aus `.page-manifest.json` eines OpenWiki-Verzeichnisses, sonst null. */
|
|
121
|
+
export function seitenListeLesen(wurzel) {
|
|
122
|
+
const pfad = join(wurzel, ".page-manifest.json");
|
|
123
|
+
if (!existsSync(pfad)) return null;
|
|
124
|
+
try {
|
|
125
|
+
return JSON.parse(readFileSync(pfad, "utf-8"))?.pages ?? null;
|
|
126
|
+
} catch {
|
|
127
|
+
return null;
|
|
128
|
+
}
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
function belegStand(belege, inhalt) {
|
|
132
|
+
if (!belege) return null;
|
|
133
|
+
const d = belege.daten;
|
|
134
|
+
if (!d || !Array.isArray(d.claims)) return { count: 0, readable: false };
|
|
135
|
+
const erste = verifiziert(d.verification)[0];
|
|
136
|
+
return {
|
|
137
|
+
count: d.claims.length,
|
|
138
|
+
// Gehören die Belege zu genau dieser Fassung der Seite? Wenn nicht, hat
|
|
139
|
+
// jemand die Seite nach der letzten Prüfung geändert.
|
|
140
|
+
page_version_current: typeof d.pageVersion === "string" ? d.pageVersion === seitenFassung(inhalt) : null,
|
|
141
|
+
...(erste ? { verified_by: erste.by, verified_at: erste.at } : {}),
|
|
142
|
+
};
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
/**
|
|
146
|
+
* Bildet den Kopf einer Seite auf `metadata` für den Upload ab. Ohne `type`
|
|
147
|
+
* im Kopf ist die Datei keine OKF-Seite (§4.1) und bekommt nichts.
|
|
148
|
+
*/
|
|
149
|
+
export function okfAngaben({ kopf, inhalt, konzept, version, belege = null, commit = null }) {
|
|
150
|
+
if (!kopf || typeof kopf.type !== "string" || !kopf.type.trim()) return null;
|
|
151
|
+
const liste = verifiziert(kopf.verified);
|
|
152
|
+
const quellen = Array.isArray(kopf.sources)
|
|
153
|
+
? kopf.sources.filter((q) => q && typeof q === "object" && q.resource != null)
|
|
154
|
+
: [];
|
|
155
|
+
const erzeugt =
|
|
156
|
+
kopf.generated && typeof kopf.generated === "object"
|
|
157
|
+
? { by: kopf.generated.by != null ? String(kopf.generated.by) : null, at: zeitpunkt(kopf.generated.at) }
|
|
158
|
+
: null;
|
|
159
|
+
const status = ["draft", "stable", "deprecated"].includes(kopf.status) ? kopf.status : "stable";
|
|
160
|
+
const okf = {
|
|
161
|
+
version,
|
|
162
|
+
concept: konzept,
|
|
163
|
+
type: kopf.type.trim(),
|
|
164
|
+
status,
|
|
165
|
+
trust: vertrauensstufe(liste),
|
|
166
|
+
...(liste.length ? { verified: liste.slice(-HOECHSTZAHL_VERIFIZIERT) } : {}),
|
|
167
|
+
...(erzeugt ? { generated: erzeugt } : {}),
|
|
168
|
+
...(zeitpunkt(kopf.stale_after) ? { stale_after: zeitpunkt(kopf.stale_after) } : {}),
|
|
169
|
+
...(typeof kopf.resource === "string" ? { resource: kopf.resource } : {}),
|
|
170
|
+
...(commit ? { git_head: commit } : {}),
|
|
171
|
+
sources_total: quellen.length,
|
|
172
|
+
...(quellen.length
|
|
173
|
+
? {
|
|
174
|
+
sources: quellen.slice(0, HOECHSTZAHL_QUELLEN).map((q) => ({
|
|
175
|
+
resource: String(q.resource),
|
|
176
|
+
...(q.author != null ? { author: String(q.author) } : {}),
|
|
177
|
+
...(zeitpunkt(q.last_modified) ? { last_modified: zeitpunkt(q.last_modified) } : {}),
|
|
178
|
+
})),
|
|
179
|
+
}
|
|
180
|
+
: {}),
|
|
181
|
+
};
|
|
182
|
+
const stand = belegStand(belege, inhalt);
|
|
183
|
+
if (stand) okf.claims = stand;
|
|
184
|
+
const gueltigAb = erzeugt?.at ?? zeitpunkt(kopf.timestamp);
|
|
185
|
+
return { okf, ...(gueltigAb ? { valid_from: gueltigAb } : {}) };
|
|
186
|
+
}
|
package/src/sync.js
CHANGED
|
@@ -11,9 +11,12 @@
|
|
|
11
11
|
* und das Manifest aktualisiert.
|
|
12
12
|
*/
|
|
13
13
|
import { readFileSync, readdirSync, statSync, writeFileSync, existsSync } from "node:fs";
|
|
14
|
-
import { join, relative, basename, extname } from "node:path";
|
|
14
|
+
import { join, relative, basename, extname, dirname } from "node:path";
|
|
15
15
|
import { createHash, randomUUID } from "node:crypto";
|
|
16
16
|
import { uploadDocument } from "./client.js";
|
|
17
|
+
import {
|
|
18
|
+
RESERVIERT, buendelWurzel, kopfLesen, belegeLesen, okfAngaben, seitenCommit, seitenListeLesen,
|
|
19
|
+
} from "./okf.js";
|
|
17
20
|
|
|
18
21
|
const DEFAULT_EXTENSIONS = [".md", ".markdown", ".txt"];
|
|
19
22
|
const MANIFEST_NAME = ".knowmind-manifest.json";
|
|
@@ -91,6 +94,59 @@ export function quellpfad(manifest, rel) {
|
|
|
91
94
|
return `${manifest.quelle}/${rel}`;
|
|
92
95
|
}
|
|
93
96
|
|
|
97
|
+
/**
|
|
98
|
+
* Findet zu einer Datei das OKF-Bündel, in dem sie liegt: den nächsten Ordner
|
|
99
|
+
* zwischen Datei und Sync-Wurzel, der ein Bündel ist (`okf.js`). Mit `--okf`
|
|
100
|
+
* gilt die Sync-Wurzel selbst als Bündel, auch ohne `okf_version`.
|
|
101
|
+
*/
|
|
102
|
+
export function buendelFinder(wurzel, erzwungen = false) {
|
|
103
|
+
const merker = new Map();
|
|
104
|
+
const ansehen = (ordner) => {
|
|
105
|
+
if (!merker.has(ordner)) {
|
|
106
|
+
const b = buendelWurzel(ordner);
|
|
107
|
+
merker.set(ordner, b ? { wurzel: ordner, ...b } : null);
|
|
108
|
+
}
|
|
109
|
+
return merker.get(ordner);
|
|
110
|
+
};
|
|
111
|
+
return (datei) => {
|
|
112
|
+
let ordner = dirname(datei);
|
|
113
|
+
for (;;) {
|
|
114
|
+
const b = ansehen(ordner);
|
|
115
|
+
if (b) return b;
|
|
116
|
+
const abstand = relative(wurzel, ordner);
|
|
117
|
+
if (abstand === "" || abstand.startsWith("..")) break;
|
|
118
|
+
const oben = dirname(ordner);
|
|
119
|
+
if (oben === ordner) break;
|
|
120
|
+
ordner = oben;
|
|
121
|
+
}
|
|
122
|
+
return erzwungen ? { wurzel, version: "unbekannt", openwiki: false } : null;
|
|
123
|
+
};
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
/**
|
|
127
|
+
* Was `knowmind sync` mit einer Datei in einem OKF-Bündel tut: auslassen
|
|
128
|
+
* (Verzeichnisliste, Verlauf, Arbeitsauftrag von OpenWiki) oder hochladen,
|
|
129
|
+
* dann mit den Angaben aus ihrem Kopf und ihren Belegen.
|
|
130
|
+
*/
|
|
131
|
+
export function okfSeite(bundle, datei, inhalt) {
|
|
132
|
+
const rel = relative(bundle.wurzel, datei).replace(/\\/g, "/");
|
|
133
|
+
if (RESERVIERT.has(basename(datei))) return { auslassen: "Verzeichnisliste oder Verlauf" };
|
|
134
|
+
// Der Arbeitsauftrag an den Schreibagenten von OpenWiki ist keine Seite.
|
|
135
|
+
if (bundle.openwiki && rel === "INSTRUCTIONS.md") return { auslassen: "Arbeitsauftrag von OpenWiki" };
|
|
136
|
+
const konzept = rel.replace(/\.md$/i, "");
|
|
137
|
+
const kopf = kopfLesen(inhalt);
|
|
138
|
+
const belege = belegeLesen(bundle.wurzel, konzept);
|
|
139
|
+
if (bundle.openwiki && bundle.seiten === undefined) bundle.seiten = seitenListeLesen(bundle.wurzel);
|
|
140
|
+
const commit = seitenCommit(bundle.seiten, rel);
|
|
141
|
+
const angaben = okfAngaben({ kopf, inhalt, konzept, version: bundle.version, belege, commit });
|
|
142
|
+
return {
|
|
143
|
+
angaben,
|
|
144
|
+
titel: angaben && typeof kopf?.title === "string" && kopf.title.trim() ? kopf.title.trim() : null,
|
|
145
|
+
// Ändern sich nur die Belege, muss die Seite trotzdem neu hinaus.
|
|
146
|
+
belegeRoh: belege?.roh ?? "",
|
|
147
|
+
};
|
|
148
|
+
}
|
|
149
|
+
|
|
94
150
|
function deriveTitle(content, filePath) {
|
|
95
151
|
const m = content.match(/^#\s+(.+)$/m);
|
|
96
152
|
if (m) return m[1].trim();
|
|
@@ -113,10 +169,13 @@ export async function syncDirectory(dir, options = {}) {
|
|
|
113
169
|
|
|
114
170
|
const files = [...walk(dir, exts)].sort();
|
|
115
171
|
const total = files.length;
|
|
172
|
+
const buendelVon = buendelFinder(dir, Boolean(options.okf));
|
|
116
173
|
let scanned = 0;
|
|
117
174
|
let uploaded = 0;
|
|
118
175
|
let skipped = 0;
|
|
119
176
|
let failed = 0;
|
|
177
|
+
let okfSeiten = 0;
|
|
178
|
+
let ausgelassen = 0;
|
|
120
179
|
const failures = [];
|
|
121
180
|
|
|
122
181
|
console.log(`Knowmind sync: ${total} Dateien in ${dir}`);
|
|
@@ -126,7 +185,15 @@ export async function syncDirectory(dir, options = {}) {
|
|
|
126
185
|
const rel = relative(dir, file).replace(/\\/g, "/");
|
|
127
186
|
if (basename(file) === MANIFEST_NAME) continue;
|
|
128
187
|
const content = readFileSync(file, "utf-8");
|
|
129
|
-
const
|
|
188
|
+
const bundle = buendelVon(file);
|
|
189
|
+
const seite = bundle ? okfSeite(bundle, file, content) : null;
|
|
190
|
+
if (seite?.auslassen) {
|
|
191
|
+
ausgelassen += 1;
|
|
192
|
+
if (options.verbose) console.log(` omit ${rel} (${seite.auslassen})`);
|
|
193
|
+
continue;
|
|
194
|
+
}
|
|
195
|
+
if (seite?.angaben) okfSeiten += 1;
|
|
196
|
+
const hash = seite?.angaben ? sha256(content + "\0" + seite.belegeRoh) : sha256(content);
|
|
130
197
|
const name = frontmatterName(content);
|
|
131
198
|
let known = manifest.files[rel];
|
|
132
199
|
let umbenanntVon = null;
|
|
@@ -146,11 +213,14 @@ export async function syncDirectory(dir, options = {}) {
|
|
|
146
213
|
continue;
|
|
147
214
|
}
|
|
148
215
|
|
|
149
|
-
const title = options.titleFromContent
|
|
216
|
+
const title = options.titleFromContent
|
|
217
|
+
? deriveTitle(content, file)
|
|
218
|
+
: seite?.titel ?? basename(file, extname(file));
|
|
150
219
|
try {
|
|
151
220
|
const result = await uploadDocument(title, content, {
|
|
152
221
|
replaceDocumentId: known?.documentId ?? undefined,
|
|
153
222
|
sourcePath: quellpfad(manifest, rel),
|
|
223
|
+
...(seite?.angaben ? { metadata: seite.angaben } : {}),
|
|
154
224
|
});
|
|
155
225
|
uploaded += 1;
|
|
156
226
|
// Server antwortet bei sha-identischem Inhalt mit unchanged:true
|
|
@@ -180,10 +250,12 @@ export async function syncDirectory(dir, options = {}) {
|
|
|
180
250
|
|
|
181
251
|
saveManifest(manifestPath, manifest);
|
|
182
252
|
console.log(`\nFertig: ${uploaded} hochgeladen, ${skipped} unverändert, ${failed} fehlerhaft.`);
|
|
253
|
+
if (okfSeiten || ausgelassen) {
|
|
254
|
+
console.log(`OKF: ${okfSeiten} Seiten mit Herkunft und Prüfstand, ${ausgelassen} Verzeichnislisten und Verläufe ausgelassen.`);
|
|
255
|
+
}
|
|
183
256
|
if (failed > 0) {
|
|
184
257
|
console.log(`Fehler-Übersicht (max 10):`);
|
|
185
258
|
failures.slice(0, 10).forEach((f) => console.log(` ${f.file}: ${f.error}`));
|
|
186
|
-
return { uploaded, skipped, failed, failures };
|
|
187
259
|
}
|
|
188
|
-
return { uploaded, skipped, failed, failures };
|
|
260
|
+
return { uploaded, skipped, failed, failures, okfSeiten, ausgelassen };
|
|
189
261
|
}
|
package/src/tools-fallback.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"_hinweis": "Rückfall für tools/list, wenn die Discovery nicht erreichbar ist. Erzeugt aus https://knowmind.de/api/mcp/v1. Abgleich: npm run tools:abgleich",
|
|
3
|
-
"stand": "2026-10-
|
|
3
|
+
"stand": "2026-10-16",
|
|
4
4
|
"quelle": "https://knowmind.de/api/mcp/v1",
|
|
5
5
|
"protocolVersion": "2025-06-18",
|
|
6
6
|
"tools": [
|
|
@@ -13,7 +13,7 @@
|
|
|
13
13
|
"idempotentHint": true,
|
|
14
14
|
"openWorldHint": false
|
|
15
15
|
},
|
|
16
|
-
"description": "Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + graph
|
|
16
|
+
"description": "Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + knowledge graph) over the tenant corpus; returns the top-k memory chunks, each with a relevance score and source reference. Suitable whenever earlier context would improve the answer; use knowmind_recall_at_time when you need what was valid at a past point in time. Read scope suffices.",
|
|
17
17
|
"inputSchema": {
|
|
18
18
|
"type": "object",
|
|
19
19
|
"properties": {
|
|
@@ -33,7 +33,7 @@
|
|
|
33
33
|
"minimum": 0,
|
|
34
34
|
"maximum": 3,
|
|
35
35
|
"default": 2,
|
|
36
|
-
"description": "
|
|
36
|
+
"description": "Accepted for compatibility (0-3, default 2); currently has no effect on recall."
|
|
37
37
|
}
|
|
38
38
|
},
|
|
39
39
|
"required": [
|
|
@@ -551,7 +551,7 @@
|
|
|
551
551
|
"idempotentHint": true,
|
|
552
552
|
"openWorldHint": false
|
|
553
553
|
},
|
|
554
|
-
"description": "DEPRECATED, removed on 2027-03-31: use knowmind_recall_memories. This name keeps answering unchanged until then. Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + graph
|
|
554
|
+
"description": "DEPRECATED, removed on 2027-03-31: use knowmind_recall_memories. This name keeps answering unchanged until then. Retrieve relevant knowledge before answering anything that benefits from prior context - decisions, preferences, project state, people, deadlines, past conversations. Hybrid recall (BM25 + pgvector + knowledge graph) over the tenant corpus; returns the top-k memory chunks, each with a relevance score and source reference. Suitable whenever earlier context would improve the answer; use knowmind_recall_at_time when you need what was valid at a past point in time. Read scope suffices.",
|
|
555
555
|
"inputSchema": {
|
|
556
556
|
"type": "object",
|
|
557
557
|
"properties": {
|
|
@@ -571,7 +571,7 @@
|
|
|
571
571
|
"minimum": 0,
|
|
572
572
|
"maximum": 3,
|
|
573
573
|
"default": 2,
|
|
574
|
-
"description": "
|
|
574
|
+
"description": "Accepted for compatibility (0-3, default 2); currently has no effect on recall."
|
|
575
575
|
}
|
|
576
576
|
},
|
|
577
577
|
"required": [
|