gigaclaw 1.6.0 → 1.7.0

package/config/brand.json

@@ -0,0 +1,23 @@
+{
+  "name": "GigaClaw",
+  "shortName": "GigaClaw",
+  "nameLower": "gigaclaw",
+  "tagline": "India's Autonomous AI Agent",
+  "taglineFull": "India's Autonomous AI Agent · Powered by Gignaati",
+  "description": "GigaClaw is an autonomous AI agent platform by Gignaati. Build, deploy, and run AI agents 24/7 with India-first, edge-native AI. Supports PragatiGPT, Claude, GPT, Gemini, and local models via Ollama.",
+  "company": "Gignaati",
+  "companyUrl": "https://www.gignaati.com",
+  "supportEmail": "support@gignaati.com",
+  "packageName": "gigaclaw",
+  "npmInstallCmd": "npx gigaclaw@latest",
+  "localPort": 3000,
+  "keywords": ["AI agent", "autonomous agent", "Gignaati", "PragatiGPT", "India AI", "edge AI", "GigaClaw"],
+  "social": {
+    "github": "https://github.com/gignaati/gigaclaw",
+    "website": "https://gigaclaw.gignaati.com"
+  },
+  "pragatigpt": {
+    "label": "PragatiGPT (Gignaati — India-first)",
+    "description": "PragatiGPT — India-first, edge-native AI by Gignaati"
+  }
+}

package/lib/brand.js

@@ -0,0 +1,88 @@
+/**
+ * lib/brand.js — Brand Abstraction Layer
+ *
+ * Single source of truth for all brand strings in GigaClaw.
+ * Reads from config/brand.json at the project root (process.cwd()).
+ * Falls back to the package-bundled config/brand.json if the user's
+ * project does not have a custom brand.json.
+ *
+ * Architecture principle: BA-ARCH (Brand-Agnostic Architecture)
+ * Rebranding requires only editing config/brand.json — zero source code changes.
+ *
+ * Usage:
+ *   import { brand } from '../lib/brand.js';
+ *   console.log(brand.name);           // "GigaClaw"
+ *   console.log(brand.tagline);        // "India's Autonomous AI Agent"
+ *   console.log(brand.company);        // "Gignaati"
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Package-bundled brand.json (authoritative default)
+const PACKAGE_BRAND_PATH = path.join(__dirname, '..', 'config', 'brand.json');
+
+// User project brand.json (optional override — allows white-labelling)
+const PROJECT_BRAND_PATH = path.join(process.cwd(), 'config', 'brand.json');
+
+function loadBrand() {
+  // Try user project override first (white-label support)
+  if (fs.existsSync(PROJECT_BRAND_PATH)) {
+    try {
+      const raw = fs.readFileSync(PROJECT_BRAND_PATH, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      // Fall through to package default
+    }
+  }
+
+  // Fall back to package-bundled brand.json
+  if (fs.existsSync(PACKAGE_BRAND_PATH)) {
+    try {
+      const raw = fs.readFileSync(PACKAGE_BRAND_PATH, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      // Fall through to hardcoded defaults
+    }
+  }
+
+  // Last-resort hardcoded defaults (should never be reached in normal operation)
+  return {
+    name: 'GigaClaw',
+    nameLower: 'gigaclaw',
+    tagline: "India's Autonomous AI Agent",
+    taglineFull: "India's Autonomous AI Agent · Powered by Gignaati",
+    description: 'GigaClaw is an autonomous AI agent platform by Gignaati.',
+    company: 'Gignaati',
+    companyUrl: 'https://www.gignaati.com',
+    packageName: 'gigaclaw',
+    npmInstallCmd: 'npx gigaclaw@latest',
+    localPort: 3000,
+    keywords: ['AI agent', 'autonomous agent', 'GigaClaw'],
+    social: {
+      github: 'https://github.com/gignaati/gigaclaw',
+      website: 'https://gigaclaw.gignaati.com',
+    },
+    pragatigpt: {
+      label: 'PragatiGPT (Gignaati — India-first)',
+      description: 'PragatiGPT — India-first, edge-native AI by Gignaati',
+    },
+  };
+}
+
+export const brand = loadBrand();
+
+// Named convenience exports for the most commonly used fields
+export const BRAND_NAME = brand.name;
+export const BRAND_TAGLINE = brand.tagline;
+export const BRAND_TAGLINE_FULL = brand.taglineFull;
+export const BRAND_COMPANY = brand.company;
+export const BRAND_COMPANY_URL = brand.companyUrl;
+export const BRAND_PACKAGE = brand.packageName;
+export const BRAND_DESCRIPTION = brand.description;
+
+export default brand;

package/lib/chat/components/app-sidebar.js

@@ -1,6 +1,7 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from "react";
+import { BRAND_NAME } from "../../brand.js";
 import { CirclePlusIcon, PanelLeftIcon, MessageIcon, BellIcon, SwarmIcon, ArrowUpCircleIcon, LifeBuoyIcon, GitPullRequestIcon, ShieldIcon } from "./icons.js";
 import { getUnreadNotificationCount, getPullRequestCount, getAppVersion } from "../actions.js";
 import { SidebarHistory } from "./sidebar-history.js";
@@ -52,7 +53,7 @@ function AppSidebar({ user }) {
       /* @__PURE__ */ jsxs(SidebarHeader, { children: [
         /* @__PURE__ */ jsxs("div", { className: collapsed ? "flex justify-center" : "flex items-center justify-between", children: [
           !collapsed && /* @__PURE__ */ jsxs("span", { className: "px-2 font-semibold text-lg", children: [
-            "GigaClaw",
+            BRAND_NAME,
             version && /* @__PURE__ */ jsxs("span", { className: "text-[11px] font-normal text-muted-foreground", children: [
               " v",
               version

package/lib/chat/components/app-sidebar.jsx

@@ -1,6 +1,7 @@
 'use client';
 
 import { useState, useEffect } from 'react';
+import { BRAND_NAME } from '../../brand.js';
 import { CirclePlusIcon, PanelLeftIcon, MessageIcon, BellIcon, SwarmIcon, ArrowUpCircleIcon, LifeBuoyIcon, GitPullRequestIcon, ShieldIcon } from './icons.js';
 import { getUnreadNotificationCount, getPullRequestCount, getAppVersion } from '../actions.js';
 import { SidebarHistory } from './sidebar-history.js';
@@ -63,7 +64,7 @@ export function AppSidebar({ user }) {
         {/* Top row: brand name + toggle icon (open) or just toggle icon (collapsed) */}
         <div className={collapsed ? 'flex justify-center' : 'flex items-center justify-between'}>
           {!collapsed && (
-            <span className="px-2 font-semibold text-lg">GigaClaw{version && <span className="text-[11px] font-normal text-muted-foreground"> v{version}</span>}</span>
+            <span className="px-2 font-semibold text-lg">{BRAND_NAME}{version && <span className="text-[11px] font-normal text-muted-foreground"> v{version}</span>}</span>
           )}
           <Tooltip>
             <TooltipTrigger asChild>

package/lib/connectors/base.js

@@ -0,0 +1,175 @@
+/**
+ * lib/connectors/base.js — BaseConnector Interface
+ *
+ * All GigaClaw connectors extend this base class.
+ * A connector bridges an external data source (filesystem, Notion, GitHub,
+ * Confluence, etc.) to the RAG ingestion pipeline.
+ *
+ * Connector lifecycle:
+ *   1. connect()    — establish connection, validate credentials
+ *   2. listFiles()  — enumerate available documents
+ *   3. fetchFile()  — retrieve a single document's content
+ *   4. sync()       — full sync: list + fetch + ingest all documents
+ *   5. disconnect() — clean up resources
+ *
+ * Implementing a new connector:
+ *   1. Extend BaseConnector
+ *   2. Override all abstract methods
+ *   3. Register in lib/connectors/registry.js
+ *   4. Add a setup step in setup/setup.mjs
+ */
+
+export class BaseConnector {
+  /**
+   * @param {Object} config - Connector-specific configuration
+   * @param {string} config.id - Unique connector instance ID
+   * @param {string} config.name - Human-readable connector name
+   */
+  constructor(config = {}) {
+    this.id = config.id || this.constructor.name.toLowerCase();
+    this.name = config.name || this.constructor.name;
+    this.config = config;
+    this._connected = false;
+  }
+
+  /**
+   * Connector type identifier. Override in subclasses.
+   * @returns {string}
+   */
+  static get type() {
+    return 'base';
+  }
+
+  /**
+   * Human-readable display name for the connector.
+   * @returns {string}
+   */
+  static get displayName() {
+    return 'Base Connector';
+  }
+
+  /**
+   * Configuration schema for the setup wizard.
+   * Return an array of field descriptors.
+   * @returns {Array<{key: string, label: string, type: 'text' | 'password' | 'path' | 'boolean', required: boolean, default?: any}>}
+   */
+  static get configSchema() {
+    return [];
+  }
+
+  /**
+   * Establish connection to the data source.
+   * Validate credentials and test connectivity.
+   * @returns {Promise<void>}
+   * @throws {Error} If connection fails
+   */
+  async connect() {
+    throw new Error(`${this.constructor.name}.connect() not implemented`);
+  }
+
+  /**
+   * List all documents available from this connector.
+   * @param {Object} [options]
+   * @param {string} [options.path] - Filter to a specific path/folder
+   * @param {string[]} [options.extensions] - Filter by file extension
+   * @returns {Promise<Array<{id: string, name: string, path: string, size: number, modifiedAt: Date, mimeType?: string}>>}
+   */
+  async listFiles(options = {}) {
+    throw new Error(`${this.constructor.name}.listFiles() not implemented`);
+  }
+
+  /**
+   * Fetch the content of a single document.
+   * @param {string} fileId - File identifier from listFiles()
+   * @returns {Promise<{text: string, metadata: Object}>}
+   */
+  async fetchFile(fileId) {
+    throw new Error(`${this.constructor.name}.fetchFile() not implemented`);
+  }
+
+  /**
+   * Perform a full sync: list all files, fetch content, ingest into RAG.
+   * Default implementation calls listFiles() + fetchFile() for each file.
+   * Override for connectors with bulk export APIs.
+   *
+   * @param {Object} [options]
+   * @param {boolean} [options.skipIndexed=true] - Skip files already in vector store
+   * @param {Function} [options.onProgress] - Callback(current, total, fileName)
+   * @returns {Promise<{synced: number, skipped: number, errors: number}>}
+   */
+  async sync(options = {}) {
+    const { skipIndexed = true, onProgress } = options;
+
+    if (!this._connected) await this.connect();
+
+    const files = await this.listFiles();
+    const stats = { synced: 0, skipped: 0, errors: 0 };
+
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (onProgress) onProgress(i + 1, files.length, file.name);
+
+      try {
+        const { text, metadata } = await this.fetchFile(file.id);
+        if (!text || text.trim().length === 0) {
+          stats.skipped++;
+          continue;
+        }
+
+        // Lazy import to avoid circular dependency
+        const { ingest } = await import('../rag/index.js');
+        // Write to a temp path for ingestion
+        const { default: os } = await import('os');
+        const { default: path } = await import('path');
+        const { default: fs } = await import('fs');
+        const tmpPath = path.join(os.tmpdir(), `gigaclaw-connector-${Date.now()}-${file.name}`);
+        fs.writeFileSync(tmpPath, text, 'utf8');
+
+        try {
+          await ingest(tmpPath);
+          stats.synced++;
+        } finally {
+          fs.unlinkSync(tmpPath);
+        }
+      } catch (err) {
+        console.error(`[Connector:${this.id}] Error syncing ${file.name}: ${err.message}`);
+        stats.errors++;
+      }
+    }
+
+    return stats;
+  }
+
+  /**
+   * Clean up resources (close connections, clear caches).
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    this._connected = false;
+  }
+
+  /**
+   * Check if the connector is currently connected.
+   * @returns {boolean}
+   */
+  get isConnected() {
+    return this._connected;
+  }
+
+  /**
+   * Validate the connector configuration.
+   * @returns {{valid: boolean, errors: string[]}}
+   */
+  validateConfig() {
+    const schema = this.constructor.configSchema;
+    const errors = [];
+
+    for (const field of schema) {
+      if (field.required && !this.config[field.key]) {
+        errors.push(`Missing required field: ${field.key}`);
+      }
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+}

package/lib/connectors/filesystem.js

@@ -0,0 +1,212 @@
+/**
+ * lib/connectors/filesystem.js — Local File System Connector
+ *
+ * Connects to a local directory and ingests all supported documents
+ * into the RAG knowledge base.
+ *
+ * This is the default connector — it watches ~/gigaclaw-docs/ by default
+ * and can be configured to watch any local directory.
+ *
+ * Configuration:
+ *   path  — Absolute path to the directory to watch (required)
+ *   watch — Whether to watch for file changes (default: true)
+ *   recursive — Whether to recurse into subdirectories (default: true)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { BaseConnector } from './base.js';
+import { isSupportedFile, extractFile, SUPPORTED_EXTENSIONS } from '../rag/extractors.js';
+import { isSourceIndexed } from '../rag/vector-store.js';
+import { startWatcher, stopWatcher, ingestFile } from '../rag/watcher.js';
+
+const DEFAULT_DOCS_DIR = path.join(os.homedir(), 'gigaclaw-docs');
+
+export class FilesystemConnector extends BaseConnector {
+  /**
+   * @param {Object} config
+   * @param {string} [config.path] - Directory to connect to
+   * @param {boolean} [config.watch=true] - Watch for changes
+   * @param {boolean} [config.recursive=true] - Recurse into subdirectories
+   */
+  constructor(config = {}) {
+    super({
+      id: 'filesystem',
+      name: 'Local File System',
+      ...config,
+    });
+    this.docsPath = config.path || process.env.RAG_DOCS_DIR || DEFAULT_DOCS_DIR;
+    this.watch = config.watch !== false;
+    this.recursive = config.recursive !== false;
+    this._watcherStarted = false;
+  }
+
+  static get type() {
+    return 'filesystem';
+  }
+
+  static get displayName() {
+    return 'Local File System';
+  }
+
+  static get configSchema() {
+    return [
+      {
+        key: 'path',
+        label: 'Documents directory',
+        type: 'path',
+        required: false,
+        default: DEFAULT_DOCS_DIR,
+        description: 'Directory containing documents to index. Defaults to ~/gigaclaw-docs/',
+      },
+      {
+        key: 'watch',
+        label: 'Watch for changes',
+        type: 'boolean',
+        required: false,
+        default: true,
+        description: 'Automatically re-index files when they change',
+      },
+      {
+        key: 'recursive',
+        label: 'Include subdirectories',
+        type: 'boolean',
+        required: false,
+        default: true,
+        description: 'Recurse into subdirectories',
+      },
+    ];
+  }
+
+  async connect() {
+    // Ensure the directory exists
+    if (!fs.existsSync(this.docsPath)) {
+      fs.mkdirSync(this.docsPath, { recursive: true });
+      console.log(`[FilesystemConnector] Created docs directory: ${this.docsPath}`);
+    }
+
+    this._connected = true;
+    console.log(`[FilesystemConnector] Connected to: ${this.docsPath}`);
+  }
+
+  /**
+   * List all supported files in the configured directory.
+   * @param {Object} [options]
+   * @param {string[]} [options.extensions] - Filter by extension
+   * @returns {Promise<Array<{id: string, name: string, path: string, size: number, modifiedAt: Date}>>}
+   */
+  async listFiles(options = {}) {
+    if (!this._connected) await this.connect();
+
+    const { extensions } = options;
+    const allowedExts = extensions
+      ? new Set(extensions.map(e => e.startsWith('.') ? e : `.${e}`))
+      : SUPPORTED_EXTENSIONS;
+
+    const files = [];
+    this._walkDir(this.docsPath, files, allowedExts);
+    return files;
+  }
+
+  /**
+   * Recursively walk the directory and collect file metadata.
+   * @private
+   */
+  _walkDir(dirPath, files, allowedExts) {
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue; // Skip hidden files/dirs
+
+        const fullPath = path.join(dirPath, entry.name);
+
+        if (entry.isDirectory() && this.recursive) {
+          this._walkDir(fullPath, files, allowedExts);
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase();
+          if (allowedExts.has(ext)) {
+            const stat = fs.statSync(fullPath);
+            files.push({
+              id: fullPath,
+              name: entry.name,
+              path: fullPath,
+              size: stat.size,
+              modifiedAt: stat.mtime,
+            });
+          }
+        }
+      }
+    } catch {
+      // Skip unreadable directories
+    }
+  }
+
+  /**
+   * Fetch the content of a file by its path (used as the file ID).
+   * @param {string} fileId - Absolute file path
+   * @returns {Promise<{text: string, metadata: Object}>}
+   */
+  async fetchFile(fileId) {
+    return extractFile(fileId);
+  }
+
+  /**
+   * Sync all files in the directory into the RAG knowledge base.
+   * @param {Object} [options]
+   * @param {boolean} [options.skipIndexed=true]
+   * @param {Function} [options.onProgress]
+   * @returns {Promise<{synced: number, skipped: number, errors: number}>}
+   */
+  async sync(options = {}) {
+    const { skipIndexed = true, onProgress } = options;
+
+    if (!this._connected) await this.connect();
+
+    const files = await this.listFiles();
+    const stats = { synced: 0, skipped: 0, errors: 0 };
+
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (onProgress) onProgress(i + 1, files.length, file.name);
+
+      if (skipIndexed && isSourceIndexed(file.path)) {
+        stats.skipped++;
+        continue;
+      }
+
+      const result = await ingestFile(file.path);
+      if (result.error) {
+        stats.errors++;
+      } else if (result.skipped) {
+        stats.skipped++;
+      } else {
+        stats.synced++;
+      }
+    }
+
+    // Start watcher if configured
+    if (this.watch && !this._watcherStarted) {
+      await startWatcher(this.docsPath);
+      this._watcherStarted = true;
+    }
+
+    return stats;
+  }
+
+  async disconnect() {
+    if (this._watcherStarted) {
+      stopWatcher();
+      this._watcherStarted = false;
+    }
+    await super.disconnect();
+  }
+
+  /**
+   * Get the docs directory path.
+   * @returns {string}
+   */
+  get docsDirectory() {
+    return this.docsPath;
+  }
+}

package/lib/connectors/index.js

@@ -0,0 +1,15 @@
+/**
+ * lib/connectors/index.js — Connector Framework Public API
+ *
+ * Export all connector classes and registry functions.
+ */
+
+export { BaseConnector } from './base.js';
+export { FilesystemConnector } from './filesystem.js';
+export {
+  registerConnector,
+  getConnectorClass,
+  listConnectors,
+  createConnector,
+  createDefaultConnector,
+} from './registry.js';

package/lib/connectors/registry.js

@@ -0,0 +1,83 @@
+/**
+ * lib/connectors/registry.js — Connector Registry
+ *
+ * Central registry for all available connectors.
+ * Connectors are registered here and can be instantiated by type.
+ *
+ * Built-in connectors:
+ *   filesystem — Local File System (default)
+ *
+ * Future connectors (v1.8+):
+ *   notion     — Notion workspace
+ *   github     — GitHub repositories
+ *   confluence — Atlassian Confluence
+ *   slack      — Slack channels
+ *   gdrive     — Google Drive
+ */
+
+import { FilesystemConnector } from './filesystem.js';
+
+/**
+ * Registry of all available connector classes.
+ * Key: connector type string
+ * Value: connector class
+ */
+const REGISTRY = new Map([
+  ['filesystem', FilesystemConnector],
+]);
+
+/**
+ * Register a custom connector class.
+ * @param {string} type - Unique type identifier
+ * @param {typeof import('./base.js').BaseConnector} ConnectorClass
+ */
+export function registerConnector(type, ConnectorClass) {
+  REGISTRY.set(type, ConnectorClass);
+}
+
+/**
+ * Get a connector class by type.
+ * @param {string} type
+ * @returns {typeof import('./base.js').BaseConnector | undefined}
+ */
+export function getConnectorClass(type) {
+  return REGISTRY.get(type);
+}
+
+/**
+ * List all registered connector types with their display names.
+ * @returns {Array<{type: string, displayName: string, configSchema: Array}>}
+ */
+export function listConnectors() {
+  return Array.from(REGISTRY.entries()).map(([type, cls]) => ({
+    type,
+    displayName: cls.displayName,
+    configSchema: cls.configSchema,
+  }));
+}
+
+/**
+ * Create a connector instance by type.
+ * @param {string} type - Connector type
+ * @param {Object} config - Connector configuration
+ * @returns {import('./base.js').BaseConnector}
+ * @throws {Error} If connector type is not registered
+ */
+export function createConnector(type, config = {}) {
+  const ConnectorClass = REGISTRY.get(type);
+  if (!ConnectorClass) {
+    throw new Error(`Unknown connector type: "${type}". Available: ${[...REGISTRY.keys()].join(', ')}`);
+  }
+  return new ConnectorClass(config);
+}
+
+/**
+ * Create and connect the default filesystem connector.
+ * @param {Object} [config]
+ * @returns {Promise<import('./filesystem.js').FilesystemConnector>}
+ */
+export async function createDefaultConnector(config = {}) {
+  const connector = new FilesystemConnector(config);
+  await connector.connect();
+  return connector;
+}