arkaos 2.3.5 → 2.4.0

package/VERSION

@@ -1 +1 @@
-2.3.5
+2.4.0

package/dashboard/app/pages/knowledge.vue

@@ -178,25 +178,45 @@ onUnmounted(() => {
 })
 
 async function handleIngest() {
-  if (!detectedType.value) return
+  if (!detectedType.value && activeInputMode.value !== 'text') return
 
   ingestError.value = null
-  const source = ingestUrl.value.trim() || ingestFile.value?.name || ''
-  const type = detectedType.value
-
-  // Clear form immediately so user can submit more
-  ingestUrl.value = ''
-  clearFile()
-  pasteText.value = ''
-  pasteTitle.value = ''
 
   try {
-    await $fetch<IngestResponse>(`${apiBase}/api/knowledge/ingest`, {
-      method: 'POST',
-      body: { source, type } satisfies IngestRequest,
-    })
+    // File upload — use multipart form
+    if (activeInputMode.value === 'file' && ingestFile.value) {
+      const formData = new FormData()
+      formData.append('file', ingestFile.value)
+      await $fetch(`${apiBase}/api/knowledge/upload-file`, {
+        method: 'POST',
+        body: formData,
+      })
+    }
+    // Text paste — save to temp file via API
+    else if (activeInputMode.value === 'text' && pasteText.value.length > 10) {
+      await $fetch(`${apiBase}/api/knowledge/ingest`, {
+        method: 'POST',
+        body: { source: pasteText.value.slice(0, 100), type: 'markdown', text: pasteText.value, title: pasteTitle.value },
+      })
+    }
+    // URL or Research — standard ingest
+    else {
+      const source = ingestUrl.value.trim()
+      const type = detectedType.value
+      if (!source || !type) return
+      await $fetch(`${apiBase}/api/knowledge/ingest`, {
+        method: 'POST',
+        body: { source, type },
+      })
+    }
+
+    // Clear form immediately
+    ingestUrl.value = ''
+    clearFile()
+    pasteText.value = ''
+    pasteTitle.value = ''
 
-    // Refresh jobs table + connect WebSocket for live updates
+    // Refresh jobs table + connect WebSocket
     fetchJobs()
     connectWebSocket()
   } catch (err) {

package/installer/index.js

@@ -13,19 +13,22 @@ const VERSION = JSON.parse(readFileSync(join(ARKAOS_ROOT, "package.json"), "utf-
 export async function install({ runtime, path, force }) {
   const startTime = Date.now();
   const config = getRuntimeConfig(runtime);
-  const installDir = path || join(homedir(), ".arkaos");
-  const isUpgrade = existsSync(join(installDir, "install-manifest.json"));
+  const isUpgrade = existsSync(join(path || join(homedir(), ".arkaos"), "install-manifest.json"));
 
   console.log(`
   ╔══════════════════════════════════════════════════════════╗
   ║  ArkaOS v${VERSION} — The Operating System for AI Agent Teams  ║
   ╚══════════════════════════════════════════════════════════╝
 
-  Runtime:     ${config.name}
-  Install dir: ${installDir}
-  Mode:        ${isUpgrade ? "Upgrade" : "Fresh install"}
+  Runtime: ${config.name}
+  Mode:    ${isUpgrade ? "Upgrade" : "Fresh install"}
   `);
 
+  // ═══ Interactive Setup ═══
+  const { runSetupPrompts } = await import("./prompts.js");
+  const userConfig = await runSetupPrompts(isUpgrade);
+  const installDir = userConfig.installDir;
+
   // ═══ Step 1: Create directories ═══
   step(1, 12, "Creating directories...");
   ensureDir(installDir);
@@ -52,9 +55,9 @@ export async function install({ runtime, path, force }) {
   const pythonCmd = checkPython();
   ok(`Found: ${pythonCmd}`);
 
-  // ═══ Step 4: Install Python core + ALL dependencies ═══
+  // ═══ Step 4: Install Python core + dependencies based on user choices ═══
   step(4, 12, "Installing Python dependencies (this may take a minute)...");
-  installAllPythonDeps(pythonCmd);
+  installAllPythonDeps(pythonCmd, userConfig);
 
   // ═══ Step 5: Copy configuration files ═══
   step(5, 12, "Copying configuration files...");
@@ -83,32 +86,60 @@ export async function install({ runtime, path, force }) {
   writeFileSync(join(skillsDir, ".arkaos-root"), ARKAOS_ROOT);
 
   const profilePath = join(installDir, "profile.json");
-  if (!existsSync(profilePath)) {
-    writeFileSync(profilePath, JSON.stringify({
-      version: "2",
-      created: new Date().toISOString(),
-    }, null, 2));
-    ok("New profile created");
-  } else {
-    ok("Existing profile preserved");
+  const profile = {
+    version: "2",
+    language: userConfig.language,
+    market: userConfig.market,
+    role: userConfig.role,
+    company: userConfig.company,
+    projectsDir: userConfig.projectsDir,
+    vaultPath: userConfig.vaultPath,
+    created: existsSync(profilePath)
+      ? JSON.parse(readFileSync(profilePath, "utf-8")).created
+      : new Date().toISOString(),
+    updated: new Date().toISOString(),
+  };
+  writeFileSync(profilePath, JSON.stringify(profile, null, 2));
+  ok("Profile saved");
+
+  // Save API keys if provided
+  if (userConfig.openaiKey || userConfig.googleKey || userConfig.falKey) {
+    const keysPath = join(installDir, "keys.json");
+    const keys = existsSync(keysPath) ? JSON.parse(readFileSync(keysPath, "utf-8")) : {};
+    if (userConfig.openaiKey) keys.OPENAI_API_KEY = userConfig.openaiKey;
+    if (userConfig.googleKey) keys.GOOGLE_API_KEY = userConfig.googleKey;
+    if (userConfig.falKey) keys.FAL_API_KEY = userConfig.falKey;
+    writeFileSync(keysPath, JSON.stringify(keys, null, 2));
+    try { chmodSync(keysPath, 0o600); } catch {}
+    ok("API keys saved");
   }
 
-  // ═══ Step 10: Index knowledge base (if vault configured) ═══
-  step(10, 12, "Checking knowledge base...");
-  const kbDb = join(installDir, "knowledge.db");
-  if (!existsSync(kbDb)) {
+  // ═══ Step 10: Index knowledge base ═══
+  step(10, 12, "Setting up knowledge base...");
+  if (userConfig.installKnowledge) {
+    const kbDb = join(installDir, "knowledge.db");
+    // Index ArkaOS skills first
     try {
       execSync(`${pythonCmd} "${join(ARKAOS_ROOT, "scripts", "knowledge-index.py")}" --dir "${join(ARKAOS_ROOT, "departments")}" --db "${kbDb}"`, {
-        stdio: "pipe",
-        timeout: 60000,
-        env: { ...process.env, ARKAOS_ROOT },
+        stdio: "pipe", timeout: 60000, env: { ...process.env, ARKAOS_ROOT },
       });
-      ok("ArkaOS skills indexed into knowledge base");
+      ok("ArkaOS skills indexed");
     } catch {
-      warn("Knowledge indexing skipped (run 'npx arkaos index' later)");
+      warn("Skill indexing skipped");
+    }
+    // Index user's Obsidian vault if provided
+    if (userConfig.vaultPath && existsSync(userConfig.vaultPath)) {
+      try {
+        execSync(`${pythonCmd} "${join(ARKAOS_ROOT, "scripts", "knowledge-index.py")}" --vault "${userConfig.vaultPath}" --db "${kbDb}"`, {
+          stdio: "pipe", timeout: 120000, env: { ...process.env, ARKAOS_ROOT },
+        });
+        ok(`Obsidian vault indexed: ${userConfig.vaultPath}`);
+      } catch {
+        warn("Vault indexing skipped (run 'npx arkaos index' later)");
+      }
     }
   } else {
-    ok("Knowledge base already exists");
+    ok("Knowledge base skipped (install later with 'npx arkaos index')");
   }
 
   // ═══ Step 11: Verify installation ═══
@@ -213,7 +244,7 @@ function checkPython() {
   process.exit(1);
 }
 
-function installAllPythonDeps(pythonCmd) {
+function installAllPythonDeps(pythonCmd, userConfig = {}) {
   // Core dependencies
   const coreDeps = "pyyaml pydantic rich click jinja2";
   // Knowledge + Vector DB
@@ -225,7 +256,11 @@ function installAllPythonDeps(pythonCmd) {
   // Transcription
   const transcriptionDeps = "faster-whisper";
 
-  const allDeps = `${coreDeps} ${knowledgeDeps} ${ingestDeps} ${dashboardDeps}`;
+  // Build deps list based on user choices
+  let allDeps = coreDeps;
+  if (userConfig.installKnowledge !== false) allDeps += ` ${knowledgeDeps}`;
+  allDeps += ` ${ingestDeps}`;
+  if (userConfig.installDashboard !== false) allDeps += ` ${dashboardDeps}`;
 
   try {
     // Try uv first (faster)

package/installer/prompts.js

@@ -0,0 +1,168 @@
+/**
+ * Interactive prompts for ArkaOS installer.
+ * Asks user for directories, language, market, preferences.
+ * Nothing is hardcoded — everything comes from the user.
+ */
+
+import { createInterface } from "node:readline";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(question, defaultValue = "") {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve) => {
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+function askYN(question, defaultYes = true) {
+  const suffix = defaultYes ? " [Y/n]" : " [y/N]";
+  return new Promise((resolve) => {
+    rl.question(`  ${question}${suffix}: `, (answer) => {
+      const a = answer.trim().toLowerCase();
+      if (!a) resolve(defaultYes);
+      else resolve(a === "y" || a === "yes");
+    });
+  });
+}
+
+function askChoice(question, options) {
+  return new Promise((resolve) => {
+    console.log(`  ${question}`);
+    options.forEach((opt, i) => {
+      console.log(`    ${i + 1}) ${opt.label}`);
+    });
+    rl.question(`  Choose [1-${options.length}]: `, (answer) => {
+      const idx = parseInt(answer.trim()) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx].value);
+      } else {
+        resolve(options[0].value); // Default to first
+      }
+    });
+  });
+}
+
+export async function runSetupPrompts(isUpgrade = false) {
+  console.log(`
+  ╔══════════════════════════════════════════════════════╗
+  ║  ArkaOS Setup — Let's configure your environment    ║
+  ╚══════════════════════════════════════════════════════╝
+  `);
+
+  const config = {};
+
+  // ── Language ──
+  config.language = await askChoice("What is your primary language?", [
+    { label: "English", value: "en" },
+    { label: "Português", value: "pt" },
+    { label: "Español", value: "es" },
+    { label: "Français", value: "fr" },
+    { label: "Deutsch", value: "de" },
+    { label: "Italiano", value: "it" },
+    { label: "中文 (Chinese)", value: "zh" },
+    { label: "日本語 (Japanese)", value: "ja" },
+    { label: "한국어 (Korean)", value: "ko" },
+    { label: "Other", value: "other" },
+  ]);
+
+  if (config.language === "other") {
+    config.language = await ask("Enter language code (e.g., nl, pl, ru)");
+  }
+
+  // ── Market/Country ──
+  config.market = await ask("What is your primary market/country?", "");
+  console.log("    (e.g., United States, Portugal, Brazil, Germany, Global)");
+  if (!config.market) {
+    config.market = await ask("Market/Country");
+  }
+
+  // ── Role ──
+  config.role = await askChoice("What best describes your role?", [
+    { label: "Developer / Engineer", value: "developer" },
+    { label: "Founder / CEO", value: "founder" },
+    { label: "Marketing / Growth", value: "marketing" },
+    { label: "Product Manager", value: "product" },
+    { label: "Designer", value: "designer" },
+    { label: "Consultant / Agency", value: "consultant" },
+    { label: "Other", value: "other" },
+  ]);
+
+  // ── Company ──
+  config.company = await ask("Company or organization name (optional)", "");
+
+  // ── Directories ──
+  console.log("\n  ── Directories ──\n");
+
+  config.projectsDir = await ask(
+    "Where are your projects?",
+    join(homedir(), "Projects")
+  );
+
+  config.vaultPath = await ask(
+    "Where is your Obsidian vault? (leave empty if none)",
+    ""
+  );
+  if (config.vaultPath && !existsSync(config.vaultPath)) {
+    console.log(`    ⚠ Directory not found: ${config.vaultPath}`);
+    const create = await askYN("Create it?", false);
+    if (!create) config.vaultPath = "";
+  }
+
+  config.installDir = await ask(
+    "ArkaOS data directory",
+    join(homedir(), ".arkaos")
+  );
+
+  // ── Features ──
+  console.log("\n  ── Optional Features ──\n");
+
+  config.installDashboard = await askYN("Install monitoring dashboard?", true);
+  config.installKnowledge = await askYN("Install knowledge base (vector DB)?", true);
+  config.installTranscription = await askYN("Install audio transcription (Whisper)?", false);
+
+  // ── API Keys (optional) ──
+  console.log("\n  ── API Keys (optional, can be configured later) ──\n");
+
+  config.openaiKey = await ask("OpenAI API key (for Whisper, embeddings — leave empty to skip)", "");
+  config.googleKey = await ask("Google API key (Gemini, Nano Banana — leave empty to skip)", "");
+  config.falKey = await ask("fal.ai API key (image/video generation — leave empty to skip)", "");
+
+  // ── Summary ──
+  console.log(`
+  ── Configuration Summary ──
+
+    Language:       ${config.language}
+    Market:         ${config.market || "(not set)"}
+    Role:           ${config.role}
+    Company:        ${config.company || "(not set)"}
+    Projects dir:   ${config.projectsDir}
+    Obsidian vault: ${config.vaultPath || "(none)"}
+    Install dir:    ${config.installDir}
+    Dashboard:      ${config.installDashboard ? "Yes" : "No"}
+    Knowledge DB:   ${config.installKnowledge ? "Yes" : "No"}
+    Transcription:  ${config.installTranscription ? "Yes" : "No"}
+    OpenAI key:     ${config.openaiKey ? "configured" : "not set"}
+    Google key:     ${config.googleKey ? "configured" : "not set"}
+    fal.ai key:     ${config.falKey ? "configured" : "not set"}
+  `);
+
+  const confirmed = await askYN("Proceed with this configuration?", true);
+  if (!confirmed) {
+    console.log("\n  Installation cancelled.\n");
+    rl.close();
+    process.exit(0);
+  }
+
+  rl.close();
+  return config;
+}
+
+export function closePrompts() {
+  try { rl.close(); } catch {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkaos",
-  "version": "2.3.5",
+  "version": "2.4.0",
   "description": "The Operating System for AI Agent Teams",
   "type": "module",
   "bin": {

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arkaos-core"
-version = "2.3.5"
+version = "2.4.0"
 description = "Core engine for ArkaOS — The Operating System for AI Agent Teams"
 readme = "README.md"
 license = {text = "MIT"}

package/scripts/dashboard-api.py

@@ -345,6 +345,71 @@ def job_cancel(job_id: str):
     return {"error": "Can only cancel queued jobs"}
 
 
+@app.post("/api/knowledge/upload")
+async def knowledge_upload(file: Any = None):
+    """Upload a file for ingestion."""
+    from fastapi import UploadFile, File as FastAPIFile
+    # Re-import with proper type
+    pass
+
+
+# Actual upload endpoint with proper signature
+from fastapi import UploadFile, File as FastAPIFile
+
+@app.post("/api/knowledge/upload-file")
+async def knowledge_upload_file(file: UploadFile):
+    """Upload and ingest a file (PDF, audio, markdown)."""
+    import threading
+
+    media_dir = Path.home() / ".arkaos" / "media"
+    media_dir.mkdir(parents=True, exist_ok=True)
+
+    # Save uploaded file
+    file_path = media_dir / file.filename
+    content = await file.read()
+    file_path.write_bytes(content)
+
+    source = str(file_path)
+    from core.knowledge.ingest import detect_source_type
+    source_type = detect_source_type(source)
+
+    store = _get_vector_store()
+    if not store:
+        from core.knowledge.vector_store import VectorStore
+        kb_db = Path.home() / ".arkaos" / "knowledge.db"
+        kb_db.parent.mkdir(parents=True, exist_ok=True)
+        store = VectorStore(kb_db)
+
+    job_mgr = _get_job_manager()
+    job = job_mgr.create(source=source, source_type=source_type, title=file.filename)
+    job_id = job.id
+
+    def run_ingest():
+        from core.jobs.manager import JobManager as _JM
+        from core.knowledge.ingest import IngestEngine
+        local_mgr = _JM()
+        engine = IngestEngine(store)
+        def on_progress(pct, msg):
+            status = "embedding" if "embed" in msg.lower() or "index" in msg.lower() else "processing"
+            local_mgr.update_progress(job_id, pct, msg, status)
+            broadcast_from_thread({"type": "job_progress", "job_id": job_id, "progress": pct, "message": msg, "status": status})
+        try:
+            local_mgr.start(job_id)
+            result = engine.ingest(source, source_type, on_progress=on_progress)
+            if result.success:
+                local_mgr.complete(job_id, chunks_created=result.chunks_created)
+                broadcast_from_thread({"type": "job_complete", "job_id": job_id, "chunks_created": result.chunks_created})
+            else:
+                local_mgr.fail(job_id, result.error)
+                broadcast_from_thread({"type": "job_failed", "job_id": job_id, "error": result.error})
+        except Exception as e:
+            local_mgr.fail(job_id, str(e))
+            broadcast_from_thread({"type": "job_failed", "job_id": job_id, "error": str(e)})
+
+    threading.Thread(target=run_ingest, daemon=True).start()
+    return {"job_id": job_id, "source_type": source_type, "filename": file.filename, "status": "queued"}
+
+
 @app.post("/api/knowledge/ingest")
 def knowledge_ingest(body: dict):
     """Ingest content into the knowledge base. Runs in background with SQLite job tracking."""
@@ -352,6 +417,21 @@ def knowledge_ingest(body: dict):
 
     source = body.get("source", "")
     source_type = body.get("type", "")
+    text_content = body.get("text", "")
+    text_title = body.get("title", "")
+
+    # Handle direct text paste — save to temp markdown file
+    if text_content and len(text_content) > 10:
+        media_dir = Path.home() / ".arkaos" / "media"
+        media_dir.mkdir(parents=True, exist_ok=True)
+        safe_name = "".join(c if c.isalnum() or c in " -_" else "" for c in (text_title or source)[:40]).strip() or "pasted-text"
+        text_path = media_dir / f"{safe_name}.md"
+        # Add title as heading
+        md_content = f"# {text_title}\n\n{text_content}" if text_title else text_content
+        text_path.write_text(md_content, encoding="utf-8")
+        source = str(text_path)
+        source_type = "markdown"
+
     if not source:
         return {"error": "source is required"}