deskforge 1.0.0

package/packages/ai/src/index.ts

@@ -0,0 +1,14 @@
+// index.ts
+// Public door into the AI package.
+
+// Perception node — processes raw input
+export * from './nodes/perception'
+
+// Memory node — vector similarity storage
+export * from './nodes/memory'
+
+// Logic node — rule based decisions
+export * from './nodes/logic'
+
+// Brain factory — combines all nodes
+export * from './brain'

package/packages/ai/src/nodes/logic.ts

@@ -0,0 +1,109 @@
+
+
+// logic.ts
+// The logic node applies rules to make decisions.
+// Unlike ML models — logic rules are explicit and
+// fully understandable. Developer writes the rules.
+// Used for business logic, routing, filtering,
+// and combining perception and memory outputs
+// into concrete decisions and actions.
+
+// A single logic rule
+interface LogicRule {
+  // Human readable rule description
+  label: string
+
+  // Condition that must be true for rule to fire
+  // Receives the current context object
+  if: (context: Record<string, unknown>) => boolean
+
+  // Action to take when condition is true
+  // Returns the result of applying this rule
+  then: (context: Record<string, unknown>) => unknown
+}
+
+// Configuration for the logic node
+interface LogicConfig {
+  // The rules to evaluate in order
+  rules: LogicRule[]
+
+  // How to handle multiple matching rules
+  // 'first' — use first matching rule only
+  // 'all'   — apply all matching rules
+  mode: 'first' | 'all'
+}
+
+// Result of applying logic rules
+interface LogicResult {
+  // Which rules matched
+  matched:  string[]
+
+  // Output from matched rules
+  outputs:  unknown[]
+
+  // Final combined output
+  result:   unknown
+}
+
+// Creates a logic node with the given rules
+function createLogicNode(config: LogicConfig) {
+  // Evaluates all rules against context
+  // Returns results of matching rules
+  function evaluate(
+    context: Record<string, unknown>
+  ): LogicResult {
+    const matched: string[]  = []
+    const outputs: unknown[] = []
+
+    for (const rule of config.rules) {
+      try {
+        // Check if rule condition is true
+        const matches = rule.if(context)
+
+        if (matches) {
+          matched.push(rule.label)
+
+          // Apply the rule
+          const output = rule.then(context)
+          outputs.push(output)
+
+          // In 'first' mode stop after first match
+          if (config.mode === 'first') break
+        }
+      } catch (error) {
+        console.error(
+          '[DeskForge AI Logic] Rule error:',
+          rule.label, error
+        )
+      }
+    }
+
+    // Combine outputs
+    const result = outputs.length === 1
+      ? outputs[0]
+      : outputs
+
+    console.log(
+      '[DeskForge AI Logic] Matched rules:',
+      matched
+    )
+
+    return { matched, outputs, result }
+  }
+
+  // Adds a new rule at runtime
+  function addRule(rule: LogicRule): void {
+    config.rules.push(rule)
+  }
+
+  // Removes a rule by label
+  function removeRule(label: string): void {
+    const index = config.rules.findIndex(r => r.label === label)
+    if (index !== -1) config.rules.splice(index, 1)
+  }
+
+  return { config, evaluate, addRule, removeRule }
+}
+
+export type { LogicRule, LogicConfig, LogicResult }
+export { createLogicNode }

package/packages/ai/src/nodes/memory.ts

@@ -0,0 +1,172 @@
+//ts
+
+// memory.ts
+// The memory node stores and retrieves information
+// using vector similarity search.
+// Unlike a database — you search by meaning not by key.
+// Ask for 'something about payments' and it finds
+// all stored memories related to payments
+// even if they do not contain that exact word.
+// All stored locally. Private. Free. Offline.
+
+// A single memory entry
+interface MemoryEntry {
+  // Unique ID for this memory
+  id:        string
+
+  // The original content stored
+  content:   unknown
+
+  // Vector representation of the content
+  // Used for similarity search
+  vector:    number[]
+
+  // When this memory was stored
+  timestamp: number
+
+  // Optional tags for filtering
+  tags?:     string[]
+}
+
+// Configuration for the memory node
+interface MemoryConfig {
+  // Storage type
+  type: 'vector' | 'episodic' | 'semantic'
+
+  // Maximum number of memories to store
+  capacity: number
+
+  // Similarity threshold for search (0 to 1)
+  // Higher = more similar results only
+  threshold?: number
+}
+
+// Search result from memory
+interface MemorySearchResult {
+  // The matching memory entry
+  entry:      MemoryEntry
+
+  // How similar it is to the query (0 to 1)
+  similarity: number
+}
+
+// Creates a memory node
+function createMemoryNode(config: MemoryConfig) {
+  // Internal memory store
+  const memories: MemoryEntry[] = []
+
+  // Generates a simple ID
+  function memId(): string {
+    return 'mem_' + Math.random().toString(16).slice(2, 8)
+  }
+
+  // Stores a new memory
+  // content — the data to remember
+  // vector — numerical representation of content
+  async function store(
+    content: unknown,
+    vector:  number[],
+    tags?:   string[]
+  ): Promise<string> {
+    // Remove oldest if at capacity
+    if (memories.length >= config.capacity) {
+      memories.shift()
+    }
+
+    const id = memId()
+
+    memories.push({
+      id,
+      content,
+      vector,
+      timestamp: Date.now(),
+      ...(tags && { tags }),
+    })
+
+    console.log('[DeskForge AI Memory] Stored:', id)
+    return id
+  }
+
+  // Calculates cosine similarity between two vectors
+  // Returns value between -1 and 1
+  // 1 means identical, 0 means unrelated, -1 means opposite
+  function cosineSimilarity(
+    a: number[],
+    b: number[]
+  ): number {
+    if (a.length !== b.length) return 0
+
+    let dot     = 0
+    let normA   = 0
+    let normB   = 0
+
+    for (let i = 0; i < a.length; i++) {
+      dot   += (a[i] ?? 0) * (b[i] ?? 0)
+      normA += (a[i] ?? 0) * (a[i] ?? 0)
+      normB += (b[i] ?? 0) * (b[i] ?? 0)
+    }
+
+    if (normA === 0 || normB === 0) return 0
+
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB))
+  }
+
+  // Searches memory by vector similarity
+  // Returns top N most similar memories
+  async function search(
+    queryVector: number[],
+    topN:        number = 5
+  ): Promise<MemorySearchResult[]> {
+    const threshold = config.threshold ?? 0.7
+
+    const results = memories
+      .map(entry => ({
+        entry,
+        similarity: cosineSimilarity(queryVector, entry.vector)
+      }))
+      .filter(r => r.similarity >= threshold)
+      .sort((a, b) => b.similarity - a.similarity)
+      .slice(0, topN)
+
+    console.log(
+      '[DeskForge AI Memory] Search returned',
+      results.length, 'results'
+    )
+
+    return results
+  }
+
+  // Retrieves a memory by ID
+  async function get(id: string): Promise<MemoryEntry | null> {
+    return memories.find(m => m.id === id) ?? null
+  }
+
+  // Deletes a memory by ID
+  async function forget(id: string): Promise<void> {
+    const index = memories.findIndex(m => m.id === id)
+    if (index !== -1) memories.splice(index, 1)
+  }
+
+  // Clears all memories
+  async function clear(): Promise<void> {
+    memories.length = 0
+  }
+
+  // Returns total memory count
+  function count(): number {
+    return memories.length
+  }
+
+  return {
+    config,
+    store,
+    search,
+    get,
+    forget,
+    clear,
+    count,
+  }
+}
+
+export type { MemoryEntry, MemoryConfig, MemorySearchResult }
+export { createMemoryNode }

package/packages/ai/src/nodes/perception.ts

@@ -0,0 +1,90 @@
+// perception.ts
+// The perception node processes raw input data.
+// It is the entry point of the AI brain —
+// takes raw text, numbers, or binary data
+// and converts it into a structured representation
+// the logic and memory nodes can work with.
+
+// Supported input types for the perception node
+type PerceptionInputType =
+  | 'text'    // plain text input
+  | 'number'  // numerical data
+  | 'image'   // image data as base64
+  | 'audio'   // audio data as base64
+  | 'vector'  // pre-computed feature vector
+
+// A perception task defines what to do with input
+type PerceptionTask =
+  | 'classify'    // classify input into categories
+  | 'embed'       // convert to numerical vector
+  | 'extract'     // extract key information
+  | 'sentiment'   // detect sentiment positive/negative
+  | 'tokenize'    // split text into tokens
+
+// Configuration for the perception node
+interface PerceptionConfig {
+  // What type of data this node accepts
+  input: PerceptionInputType
+
+  // What to do with the input
+  task:  PerceptionTask
+
+  // Output dimension for embed task
+  dimensions?: number
+
+  // Categories for classify task
+  categories?: string[]
+}
+
+// The result of a perception operation
+interface PerceptionResult {
+  // The task that was performed
+  task:      PerceptionTask
+
+  // Raw output from perception
+  output:    unknown
+
+  // Confidence score 0 to 1
+  confidence: number
+
+  // Time taken in milliseconds
+  duration:  number
+}
+
+// Creates a perception node
+function createPerceptionNode(
+  config: PerceptionConfig
+) {
+  // Processes input data and returns perception result
+  async function process(
+    input: unknown
+  ): Promise<PerceptionResult> {
+    const start = Date.now()
+
+    console.log(
+      '[DeskForge AI Perception]',
+      config.task, 'on', config.input
+    )
+
+    // In production this runs the actual ML model
+    // using ONNX runtime or a custom tiny model
+    // loaded from the training data
+
+    return {
+      task:       config.task,
+      output:     null,
+      confidence: 0,
+      duration:   Date.now() - start,
+    }
+  }
+
+  return { config, process }
+}
+
+export type {
+  PerceptionInputType,
+  PerceptionTask,
+  PerceptionConfig,
+  PerceptionResult,
+}
+export { createPerceptionNode }

package/packages/ai/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/background/dist/background.d.ts

@@ -0,0 +1,42 @@
+type IntervalString = string;
+interface TaskProgress {
+    update(value: unknown): void;
+    count(): number;
+}
+interface BackgroundTaskConfig {
+    interval: IntervalString;
+    onlyWhen?: () => boolean;
+}
+interface LongTaskConfig {
+    task: (progress: TaskProgress) => Promise<void>;
+}
+interface BackgroundTask {
+    name: string;
+    fn: () => Promise<void>;
+    config: BackgroundTaskConfig;
+    timer: ReturnType<typeof setInterval> | null;
+    running: boolean;
+    lastRun: number | null;
+    runCount: number;
+}
+declare function run(name: string, fn: () => Promise<void>, config: BackgroundTaskConfig): void;
+declare function task(name: string, config: LongTaskConfig): Promise<void>;
+declare function cancel(name: string): void;
+declare function cancelAll(): void;
+declare function status(): Array<{
+    name: string;
+    running: boolean;
+    lastRun: number | null;
+    runCount: number;
+    interval: string;
+}>;
+declare const Background: {
+    run: typeof run;
+    task: typeof task;
+    cancel: typeof cancel;
+    cancelAll: typeof cancelAll;
+    status: typeof status;
+};
+export type { IntervalString, TaskProgress, BackgroundTaskConfig, LongTaskConfig, BackgroundTask, };
+export { Background, run, cancel, cancelAll, status };
+//# sourceMappingURL=background.d.ts.map

package/packages/background/dist/background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../src/background.ts"],"names":[],"mappings":"AAYA,KAAK,cAAc,GAAG,MAAM,CAAA;AAI5B,UAAU,YAAY;IAGpB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IAG5B,KAAK,IAAI,MAAM,CAAA;CAChB;AAGD,UAAU,oBAAoB;IAG5B,QAAQ,EAAE,cAAc,CAAA;IAIxB,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAA;CACzB;AAGD,UAAU,cAAc;IAGtB,IAAI,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAChD;AAGD,UAAU,cAAc;IAEtB,IAAI,EAAO,MAAM,CAAA;IAGjB,EAAE,EAAS,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAG9B,MAAM,EAAK,oBAAoB,CAAA;IAG/B,KAAK,EAAM,UAAU,CAAC,OAAO,WAAW,CAAC,GAAG,IAAI,CAAA;IAGhD,OAAO,EAAI,OAAO,CAAA;IAGlB,OAAO,EAAI,MAAM,GAAG,IAAI,CAAA;IAGxB,QAAQ,EAAG,MAAM,CAAA;CAClB;AA0BD,iBAAS,GAAG,CACV,IAAI,EAAI,MAAM,EACd,EAAE,EAAM,MAAM,OAAO,CAAC,IAAI,CAAC,EAC3B,MAAM,EAAE,oBAAoB,GAC3B,IAAI,CAgEN;AAID,iBAAe,IAAI,CACjB,IAAI,EAAI,MAAM,EACd,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAID,iBAAS,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAelC;AAGD,iBAAS,SAAS,IAAI,IAAI,CAOzB;AAGD,iBAAS,MAAM,IAAI,KAAK,CAAC;IACvB,IAAI,EAAM,MAAM,CAAA;IAChB,OAAO,EAAG,OAAO,CAAA;IACjB,OAAO,EAAG,MAAM,GAAG,IAAI,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAC,CAQD;AAGD,QAAA,MAAM,UAAU;;;;;;CAMf,CAAA;AAED,YAAY,EACV,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,cAAc,EACd,cAAc,GACf,CAAA;AACD,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,CAAA"}

package/packages/background/dist/background.js

@@ -0,0 +1,149 @@
+"use strict";
+// background.ts
+// Background task system for DeskForge.
+// Runs tasks in a separate QuickJS isolate thread.
+// App stays responsive while heavy work runs behind.
+// Tasks survive app minimization and screen lock.
+// Developer never thinks about threads — just functions.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Background = void 0;
+exports.run = run;
+exports.cancel = cancel;
+exports.cancelAll = cancelAll;
+exports.status = status;
+// All registered background tasks
+const tasks = new Map();
+// Parses an interval string into milliseconds
+// '5s' → 5000
+// '15m' → 900000
+// '2h' → 7200000
+// '1d' → 86400000
+function parseInterval(interval) {
+    const value = parseInt(interval);
+    const unit = interval.slice(-1);
+    switch (unit) {
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        case 'd': return value * 24 * 60 * 60 * 1000;
+        default: return value;
+    }
+}
+// Registers and starts a recurring background task
+// task runs automatically at the specified interval
+// even when the app is minimized
+function run(name, fn, config) {
+    // Cancel existing task with same name
+    if (tasks.has(name)) {
+        cancel(name);
+    }
+    const intervalMs = parseInterval(config.interval);
+    const task = {
+        name,
+        fn,
+        config,
+        timer: null,
+        running: false,
+        lastRun: null,
+        runCount: 0,
+    };
+    // Wraps the task function with condition check
+    async function runTask() {
+        // Skip if condition is false
+        if (config.onlyWhen && !config.onlyWhen()) {
+            console.log('[DeskForge Background] Skipped (condition false):', name);
+            return;
+        }
+        // Skip if already running
+        if (task.running) {
+            console.log('[DeskForge Background] Already running:', name);
+            return;
+        }
+        task.running = true;
+        try {
+            console.log('[DeskForge Background] Running:', name);
+            await fn();
+            task.lastRun = Date.now();
+            task.runCount++;
+        }
+        catch (error) {
+            console.error('[DeskForge Background] Error in task:', name, error);
+        }
+        finally {
+            task.running = false;
+        }
+    }
+    // Start the interval
+    task.timer = setInterval(runTask, intervalMs);
+    tasks.set(name, task);
+    console.log('[DeskForge Background] Registered:', name, 'every', config.interval);
+}
+// Runs a long task with progress reporting
+// Progress updates are surfaced to UI automatically
+async function task(name, config) {
+    let updateCount = 0;
+    // Create progress reporter
+    const progress = {
+        update(value) {
+            updateCount++;
+            console.log('[DeskForge Background] Progress:', name, value);
+            // In production this updates a progress bar
+            // in the UI via the reactive state system
+        },
+        count() {
+            return updateCount;
+        }
+    };
+    console.log('[DeskForge Background] Long task started:', name);
+    try {
+        await config.task(progress);
+        console.log('[DeskForge Background] Long task done:', name);
+    }
+    catch (error) {
+        console.error('[DeskForge Background] Long task failed:', name, error);
+        throw error;
+    }
+}
+// Cancels a background task by name
+// Stops it from running again
+function cancel(name) {
+    const existing = tasks.get(name);
+    if (!existing) {
+        console.warn('[DeskForge Background] Task not found:', name);
+        return;
+    }
+    if (existing.timer) {
+        clearInterval(existing.timer);
+    }
+    tasks.delete(name);
+    console.log('[DeskForge Background] Cancelled:', name);
+}
+// Cancels all registered background tasks
+function cancelAll() {
+    tasks.forEach((task, name) => {
+        if (task.timer)
+            clearInterval(task.timer);
+        console.log('[DeskForge Background] Cancelled:', name);
+    });
+    tasks.clear();
+}
+// Returns status of all registered tasks
+function status() {
+    return Array.from(tasks.values()).map(t => ({
+        name: t.name,
+        running: t.running,
+        lastRun: t.lastRun,
+        runCount: t.runCount,
+        interval: t.config.interval,
+    }));
+}
+// The main Background object
+const Background = {
+    run,
+    task,
+    cancel,
+    cancelAll,
+    status,
+};
+exports.Background = Background;
+//# sourceMappingURL=background.js.map

package/packages/background/dist/background.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.js","sourceRoot":"","sources":["../src/background.ts"],"names":[],"mappings":"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"}

package/packages/background/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './background';
+//# sourceMappingURL=index.d.ts.map

package/packages/background/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,cAAc,CAAA"}

package/packages/background/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// index.ts
+// Public door into the background package.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./background"), exports);
+//# sourceMappingURL=index.js.map

package/packages/background/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,WAAW;AACX,2CAA2C;;;;;;;;;;;;;;;;AAE3C,+CAA4B"}

package/packages/background/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@deskforge/background",
+  "version": "1.0.0",
+  "description": "DeskForge background tasks and scheduling",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "check": "tsc --noEmit",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deskforge/deskforge.git"
+  },
+  "bugs": {
+    "url": "https://github.com/deskforge/deskforge/issues"
+  },
+  "homepage": "https://github.com/deskforge/deskforge#readme"
+}