@dotdrelle/wiki-manager 0.6.30 → 0.6.34

package/src/core/compose.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
 import YAML from 'yaml';
+import { cacertEnv, ensureCacertComposeOverride } from './cacert.js';
 import { managerEnvFile, readEnvFile } from './env.js';
 import { managerRoot } from './workspaces.js';
 
@@ -93,14 +94,14 @@ function projectName(session) {
 }
 
 function composeBaseArgs(session) {
-  const args = ['compose', '-f', composeFile(), '-p', projectName(session)];
+  const compose = composeFile();
+  const cacertOverride = ensureCacertComposeOverride(compose);
+  const args = ['compose', '-f', compose];
+  if (cacertOverride) args.push('-f', cacertOverride);
+  args.push('-p', projectName(session));
   const managerEnvPath = managerEnvFile();
-  if (existsSync(managerEnvPath)) {
-    args.push('--env-file', managerEnvPath);
-  }
-  if (session.workspaceEnvFile && existsSync(session.workspaceEnvFile)) {
-    args.push('--env-file', session.workspaceEnvFile);
-  }
+  if (existsSync(managerEnvPath)) args.push('--env-file', managerEnvPath);
+  if (session.workspaceEnvFile && existsSync(session.workspaceEnvFile)) args.push('--env-file', session.workspaceEnvFile);
   return args;
 }
 
@@ -109,6 +110,7 @@ function composeEnv(session) {
     ...process.env,
     ...readManagerEnv(),
     ...(session.workspaceEnv ?? {}),
+    ...cacertEnv(),
     WORKSPACE_NAME: session.workspace,
     WIKI_WORKSPACE_PATH: session.workspacePath,
   };
@@ -236,7 +238,7 @@ export async function composePs(session) {
   return runCompose(session, ['ps'], { timeout: 30_000 });
 }
 
-function parseComposePsJson(output) {
+export function parseComposePsJson(output) {
   const text = output.trim();
   if (!text) return [];
   try {

package/src/core/env.js

@@ -1,18 +1,28 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 
 export function userManagerDir() {
   return process.cwd();
 }
 
+export function managerStateDir() {
+  return process.env.WIKI_MANAGER_ENV_FILE
+    ? dirname(resolve(process.env.WIKI_MANAGER_ENV_FILE))
+    : userManagerDir();
+}
+
+export function managerRuntimeDir() {
+  return join(managerStateDir(), '.wiki-manager');
+}
+
 export function managerEnvFile() {
   return process.env.WIKI_MANAGER_ENV_FILE
     ? resolve(process.env.WIKI_MANAGER_ENV_FILE)
-    : join(userManagerDir(), '.env');
+    : join(managerStateDir(), '.env');
 }
 
 export function managerMcpEndpointsFile() {
-  return join(userManagerDir(), 'mcp.endpoints.json');
+  return join(managerStateDir(), 'mcp.endpoints.json');
 }
 
 function parseEnvValue(value) {

package/src/core/mcp.js

@@ -211,7 +211,7 @@ async function mcpRequest(endpoint, method, params, signal, options = {}) {
           params: {
             protocolVersion: '2025-06-18',
             capabilities: {},
-            clientInfo: { name: 'wiki-manager', version: '0.6.30' },
+            clientInfo: { name: 'wiki-manager', version: '0.6.34' },
           },
         }),
       });

package/src/core/modelFetch.js

@@ -0,0 +1,97 @@
+const FALLBACK_MODELS = {
+  openai: ['gpt-5.4', 'gpt-5.4-mini', 'gpt-4.1', 'gpt-4.1-mini'],
+  anthropic: ['claude-sonnet-4-5', 'claude-opus-4-1', 'claude-3-7-sonnet-latest'],
+  ollama: ['llama3.2', 'qwen2.5', 'mistral', 'nomic-embed-text'],
+  'openai-compatible': ['gpt-4.1-mini', 'llama3.2'],
+  other: ['gpt-4.1-mini', 'llama3.2'],
+};
+
+const FALLBACK_EMBEDDINGS = {
+  openai: ['text-embedding-3-small', 'text-embedding-3-large'],
+  anthropic: ['text-embedding-3-small'],
+  ollama: ['nomic-embed-text', 'mxbai-embed-large'],
+  'openai-compatible': ['BAAI/bge-m3', 'text-embedding-3-small', 'nomic-embed-text'],
+  other: ['text-embedding-3-small', 'nomic-embed-text'],
+};
+
+export function normalizeProvider(provider) {
+  const value = String(provider ?? '').toLowerCase();
+  if (value.includes('compatible') || value.includes('other')) return 'openai-compatible';
+  if (value.includes('anthropic')) return 'anthropic';
+  if (value.includes('ollama')) return 'ollama';
+  if (value.includes('openai')) return 'openai';
+  return 'openai-compatible';
+}
+
+function fallbackFor(provider, kind) {
+  const normalized = normalizeProvider(provider);
+  const source = kind === 'embedding' ? FALLBACK_EMBEDDINGS : FALLBACK_MODELS;
+  return source[normalized] ?? source.other;
+}
+
+function endpointFor(provider, baseUrl) {
+  const normalized = normalizeProvider(provider);
+  if (normalized === 'anthropic') return 'https://api.anthropic.com/v1/models';
+  const root = String(baseUrl || (normalized === 'ollama' ? 'http://localhost:11434' : 'https://api.openai.com')).replace(/\/+$/g, '');
+  return normalized === 'ollama' ? `${root}/api/tags` : `${root}/v1/models`;
+}
+
+function headersFor(provider, apiKey) {
+  const normalized = normalizeProvider(provider);
+  if (normalized === 'ollama') return {};
+  if (normalized === 'anthropic') {
+    return {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    };
+  }
+  return { Authorization: `Bearer ${apiKey}` };
+}
+
+function parseModelNames(provider, payload) {
+  const normalized = normalizeProvider(provider);
+  const items = normalized === 'ollama' ? payload?.models : payload?.data;
+  if (!Array.isArray(items)) return [];
+  return items
+    .map((item) => item?.id ?? item?.name ?? item?.model)
+    .filter(Boolean)
+    .map(String)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+export async function fetchModels(provider, baseUrl, apiKey, options = {}) {
+  const normalized = normalizeProvider(provider);
+  if (normalized === 'anthropic') {
+    return { ok: false, models: fallbackFor(normalized, options.kind), source: 'fallback', error: 'Anthropic model listing is not supported' };
+  }
+  const timeoutMs = options.timeoutMs ?? 10000;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    if (normalized !== 'ollama' && !apiKey) {
+      throw new Error('API key is required to fetch remote models');
+    }
+    const response = await fetch(endpointFor(normalized, baseUrl), {
+      headers: headersFor(normalized, apiKey),
+      signal: controller.signal,
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const payload = await response.json();
+    const models = parseModelNames(normalized, payload);
+    if (models.length === 0) throw new Error('No models returned');
+    return { ok: true, models, source: 'remote' };
+  } catch (err) {
+    return {
+      ok: false,
+      models: fallbackFor(normalized, options.kind),
+      source: 'fallback',
+      error: err instanceof Error ? err.message : String(err),
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function fallbackModels(provider, kind) {
+  return fallbackFor(provider, kind);
+}

package/src/core/modelFetch.test.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { fallbackModels, fetchModels } from './modelFetch.js';
+
+test('fetchModels returns remote OpenAI-compatible model ids', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    json: async () => ({ data: [{ id: 'b-model' }, { id: 'a-model' }] }),
+  });
+  try {
+    const result = await fetchModels('openai', 'http://models.local', 'key', { timeoutMs: 100 });
+    assert.deepEqual(result, { ok: true, models: ['a-model', 'b-model'], source: 'remote' });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('fetchModels falls back on invalid remote response', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    json: async () => ({ data: [] }),
+  });
+  try {
+    const result = await fetchModels('openai', 'http://models.local', 'key', { timeoutMs: 100 });
+    assert.equal(result.ok, false);
+    assert.equal(result.source, 'fallback');
+    assert.ok(result.models.includes('gpt-5.4-mini'));
+    assert.match(result.error, /No models returned/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('fallbackModels leaves custom-model to the wizard append action', () => {
+  assert.deepEqual(fallbackModels('openai-compatible'), ['gpt-4.1-mini', 'llama3.2']);
+});

package/src/core/startupCheck.js

@@ -0,0 +1,130 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { parseComposePsJson } from './compose.js';
+import { listWikircProfiles, loadWikircProfile, summarizeWikircConfig } from './wikirc.js';
+import { listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
+
+const execFileAsync = promisify(execFile);
+
+async function checkAgents() {
+  const composeFile = join(managerRoot(), 'agents.docker-compose.yml');
+  if (!existsSync(composeFile)) return null;
+  try {
+    const { stdout } = await execFileAsync('docker', [
+      'compose',
+      '--project-directory',
+      managerRoot(),
+      '-f',
+      composeFile,
+      '-p',
+      'wiki-agents',
+      'ps',
+      '--format',
+      'json',
+    ], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WORKSPACES_ROOT: workspacesDir(),
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: 5000,
+      maxBuffer: 1024 * 1024,
+    });
+    const entries = parseComposePsJson(stdout);
+    if (entries.length === 0) return null;
+    const downServices = entries
+      .filter((entry) => {
+        const state = String(entry.State ?? entry.state ?? entry.Status ?? entry.status ?? '').toLowerCase();
+        return !(state.includes('running') || state.includes('up'));
+      })
+      .map((entry) => entry.Service ?? entry.service ?? entry.Name ?? entry.name)
+      .filter(Boolean);
+    return downServices.length > 0 ? { kind: 'agents', context: { downServices } } : null;
+  } catch (err) {
+    if (err?.code === 'ENOENT') {
+      return { kind: 'agents', context: { dockerMissing: true } };
+    }
+    const stderr = String(err?.stderr ?? err?.message ?? '');
+    if (
+      stderr.includes('Cannot connect to the Docker daemon') ||
+      stderr.includes('Is the docker daemon running') ||
+      stderr.includes('docker daemon') ||
+      stderr.includes('connection refused')
+    ) {
+      return { kind: 'agents', context: { dockerUnavailable: true } };
+    }
+    // Timeout or unknown error — don't block startup with ambiguous state.
+    return null;
+  }
+}
+
+function checkWorkspace(workspaces) {
+  return workspaces.length === 0 ? { kind: 'workspace' } : null;
+}
+
+function checkWikirc(workspace) {
+  if (!workspace) return [];
+  const baseContext = {
+    workspaceName: workspace.name,
+    workspacePath: workspace.workspacePath,
+    profileName: 'default',
+  };
+  if (listWikircProfiles(workspace.workspacePath).length === 0) {
+    return [
+      {
+        kind: 'llm',
+        context: {
+          ...baseContext,
+          configError: 'No .wikirc.yaml profile found in the workspace.',
+        },
+      },
+    ];
+  }
+  try {
+    const loaded = loadWikircProfile(workspace.workspacePath, 'default');
+    const summary = summarizeWikircConfig(loaded.profile, loaded.config);
+    const context = {
+      workspaceName: workspace.name,
+      workspacePath: workspace.workspacePath,
+      profileName: loaded.profile.name,
+    };
+    const gaps = [];
+    if (!summary.hasApiKey || !summary.model) gaps.push({ kind: 'llm', context });
+    if (!summary.vectorEnabled) gaps.push({ kind: 'vector', context });
+    return gaps;
+  } catch {
+    return [
+      {
+        kind: 'llm',
+        context: {
+          ...baseContext,
+          configError: 'Default .wikirc.yaml profile could not be loaded.',
+        },
+      },
+      {
+        kind: 'vector',
+        context: {
+          ...baseContext,
+          configError: 'Default .wikirc.yaml profile could not be loaded.',
+        },
+      },
+    ];
+  }
+}
+
+export async function runChecks() {
+  const workspaces = listWorkspaces();
+  const agents = await checkAgents();
+  const gaps = [];
+  if (agents) gaps.push(agents);
+  const workspaceGap = checkWorkspace(workspaces);
+  if (workspaceGap) {
+    gaps.push(workspaceGap);
+    return gaps;
+  }
+  gaps.push(...checkWikirc(workspaces[0] ?? null));
+  return gaps;
+}

package/src/core/wikiSetup.js

@@ -0,0 +1,156 @@
+import { execFile } from 'node:child_process';
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { patchWikircProfile } from './wikirc.js';
+import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
+
+const execFileAsync = promisify(execFile);
+
+function wrapDockerError(err) {
+  if (err?.code === 'ENOENT') {
+    return new Error('wiki-workspace script not found. Reinstall wiki-manager.');
+  }
+  const message = String(err?.message ?? '');
+  const output = [err?.stderr, err?.stdout, message].filter(Boolean).map(String).join('\n');
+  if (output.includes('docker: command not found') || output.includes('docker: not found')) {
+    return new Error('Docker is not installed. Install Docker Desktop (https://docs.docker.com/get-docker/) and restart.');
+  }
+  if (output.includes('Cannot connect to the Docker daemon') || output.includes('Is the docker daemon running')) {
+    return new Error('Docker daemon is not running. Start Docker Desktop and try again.');
+  }
+  const commandMatch = message.match(/^Command failed:\s+(.+)$/m);
+  if (commandMatch) {
+    const [, commandLine] = commandMatch;
+    const rest = message.split(/\r?\n/).slice(1).join('\n').trim();
+    return new Error([
+      'Command failed:',
+      commandLine,
+      rest,
+    ].filter(Boolean).join('\n'));
+  }
+  return err;
+}
+
+export async function startAgents(options = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'up'], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: options.timeout ?? 180_000,
+      maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+    });
+    return [stdout, stderr].filter(Boolean).join('\n').trim();
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export async function stopAgents(options = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync(join(managerRoot(), 'wiki-workspace'), ['agents', 'down'], {
+      cwd: managerRoot(),
+      env: {
+        ...process.env,
+        WIKI_WORKSPACES_DIR: workspacesDir(),
+      },
+      timeout: options.timeout ?? 120_000,
+      maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+    });
+    return [stdout, stderr].filter(Boolean).join('\n').trim();
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export async function createNewWorkspace(name, targetPath) {
+  try {
+    const output = await createWorkspace(name, targetPath, { timeout: 600_000 });
+    const workspace = findWorkspace(name);
+    if (workspace) initializeWorkspaceWikirc(workspace);
+    return { output, workspace };
+  } catch (err) {
+    throw wrapDockerError(err);
+  }
+}
+
+export function initializeWorkspaceWikirc(workspace) {
+  const accessKey = workspace?.env?.WIKI_MCP_AUTH_TOKEN;
+  if (!workspace?.workspacePath || !accessKey) return null;
+  return patchWikircProfile(workspace.workspacePath, 'default', {
+    mcp: {
+      accessKey,
+    },
+  });
+}
+
+export async function unregisterWorkspace(nameOrWorkspace) {
+  const workspace = typeof nameOrWorkspace === 'string' ? findWorkspace(nameOrWorkspace) : nameOrWorkspace;
+  if (!workspace) throw new Error(`Workspace not found: ${nameOrWorkspace}`);
+  await rm(workspace.registryPath, { recursive: true, force: true });
+  return workspace;
+}
+
+export async function renameWorkspace(name, nextName) {
+  if (!isValidWorkspaceName(nextName)) throw new Error('Invalid workspace name.');
+  const all = listWorkspaces();
+  const workspace = all.find((w) => w.name === name);
+  if (!workspace) throw new Error(`Workspace not found: ${name}`);
+  if (all.find((w) => w.name === nextName)) throw new Error(`Workspace already exists: ${nextName}`);
+  const nextRegistryPath = join(workspacesDir(), nextName);
+  const envText = await readFile(workspace.envFile, 'utf8');
+  const nextEnvText = envText.match(/^WORKSPACE_NAME=/m)
+    ? envText.replace(/^WORKSPACE_NAME=.*$/m, `WORKSPACE_NAME=${nextName}`)
+    : `${envText.trimEnd()}\nWORKSPACE_NAME=${nextName}\n`;
+  const tmpEnvFile = join(workspace.registryPath, `.env.${process.pid}.tmp`);
+  await writeFile(tmpEnvFile, nextEnvText, 'utf8');
+  await rename(tmpEnvFile, workspace.envFile);
+  await rename(workspace.registryPath, nextRegistryPath);
+  return { previousName: name, name: nextName, registryPath: nextRegistryPath };
+}
+
+export async function deleteWorkspaceAndFiles(name, workspacePath) {
+  const workspace = await unregisterWorkspace(name);
+  const target = workspacePath || workspace.workspacePath;
+  await rm(target, { recursive: true, force: true });
+  return { workspace, deletedPath: target };
+}
+
+export function writeLanguageConfig(workspacePath, profileName, language) {
+  return patchWikircProfile(workspacePath, profileName || 'default', { language });
+}
+
+export function writeLlmConfig(workspacePath, profileName, config) {
+  const patches = {
+    llm: {
+      provider: config.provider,
+      ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+      ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+      model: config.model,
+    },
+  };
+  return patchWikircProfile(workspacePath, profileName || 'default', patches);
+}
+
+export function writeVectorConfig(workspacePath, profileName, config) {
+  const patches = {
+    retrieval: {
+      vector: {
+        enabled: true,
+        ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+        ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+        timeoutMs: config.timeoutMs ?? 600_000,
+        embeddingModel: config.embeddingModel,
+        rerankEnabled: Boolean(config.rerankEnabled),
+        ...(config.rerankerModel ? { rerankerModel: config.rerankerModel } : {}),
+        topK: config.topK ?? 120,
+        rerankTopK: config.rerankTopK ?? 80,
+        maxResults: config.maxResults ?? 6,
+      },
+    },
+  };
+  return patchWikircProfile(workspacePath, profileName || 'default', patches);
+}

package/src/core/wikirc.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import YAML from 'yaml';
 
@@ -50,6 +50,85 @@ export function loadWikircProfile(workspacePath, profileName = 'default') {
   return { profile, config };
 }
 
+function isPlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function setYamlValue(map, key, value) {
+  if (isPlainObject(value)) {
+    let child = map.get(key, true);
+    if (!YAML.isMap(child)) {
+      child = new YAML.YAMLMap();
+      map.set(key, child);
+    }
+    mergeYamlMap(child, value);
+    return;
+  }
+  map.set(key, value);
+}
+
+function mergeYamlMap(map, patches) {
+  for (const [key, value] of Object.entries(patches ?? {})) {
+    setYamlValue(map, key, value);
+  }
+}
+
+function stripCommentedVectorKeys(raw, keys) {
+  const keySet = new Set(keys.filter(Boolean));
+  if (keySet.size === 0) return raw;
+
+  let inRetrieval = false;
+  let retrievalIndent = -1;
+  let inVector = false;
+  let vectorIndent = -1;
+
+  return raw.split(/\r?\n/).filter((line) => {
+    const nonComment = line.match(/^(\s*)([A-Za-z0-9_-]+):(?:\s|$)/);
+    if (nonComment) {
+      const indent = nonComment[1].length;
+      const key = nonComment[2];
+      if (inVector && indent <= vectorIndent) inVector = false;
+      if (inRetrieval && indent <= retrievalIndent) inRetrieval = false;
+      if (!inRetrieval && key === 'retrieval') {
+        inRetrieval = true;
+        retrievalIndent = indent;
+      } else if (inRetrieval && !inVector && indent > retrievalIndent && key === 'vector') {
+        inVector = true;
+        vectorIndent = indent;
+      }
+    }
+
+    if (inVector) {
+      const commentedKey = line.match(/^\s*#\s*([A-Za-z0-9_-]+):/);
+      if (commentedKey && keySet.has(commentedKey[1])) return false;
+    }
+    return true;
+  }).join('\n');
+}
+
+export function patchWikircProfile(workspacePath, profileName = 'default', patches = {}) {
+  const profile = resolveWikircProfile(workspacePath, profileName);
+  const vectorPatch = patches?.retrieval?.vector;
+  const commentedVectorKeysToStrip = [
+    vectorPatch?.baseUrl ? 'baseUrl' : null,
+    vectorPatch?.apiKey ? 'apiKey' : null,
+  ];
+  const raw = stripCommentedVectorKeys(readFileSync(profile.path, 'utf8'), commentedVectorKeysToStrip);
+  const doc = YAML.parseDocument(raw, {
+    schema: 'core',
+    keepSourceTokens: true,
+  });
+  if (doc.errors.length > 0) {
+    throw new Error(`wikirc YAML invalide: ${doc.errors[0].message}`);
+  }
+  if (!YAML.isMap(doc.contents)) {
+    throw new Error('wikirc YAML invalide: objet attendu a la racine');
+  }
+  mergeYamlMap(doc.contents, patches);
+  writeFileSync(profile.path, doc.toString(), 'utf8');
+  return { profile, patches };
+}
+
 export function summarizeWikircConfig(profile, config) {
   return {
     profile: profile.name,