anymous 1.2.3 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anymous",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "AI-powered reverse engineering platform",
   "type": "module",
   "license": "MIT",

package/src/cli/cmd/run/footer.ts

@@ -29,7 +29,7 @@ import type { Keymap } from "@opentui/keymap"
 import { render } from "@opentui/solid"
 import { createComponent, createSignal, type Accessor, type Setter } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { anymousKeymapProvider } from "@anymous-ai/tui/keymap"
+import { anymousKeymapProvider, type OpenTuiKeymap } from "@anymous-ai/tui/keymap"
 import { RUN_COMMAND_PANEL_ROWS, RUN_SUBAGENT_PANEL_ROWS } from "./footer.command"
 import { SUBAGENT_INSPECTOR_ROWS } from "./footer.subagent"
 import { PROMPT_MAX_ROWS, TEXTAREA_MIN_ROWS } from "./footer.prompt"
@@ -301,7 +301,7 @@ export class RunFooter implements FooterApi {
     void render(
       () =>
         createComponent(anymousKeymapProvider, {
-          keymap: options.keymap,
+          keymap: options.keymap as unknown as OpenTuiKeymap,
           get children() {
             return createComponent(RunFooterView, {
               directory: options.directory,

package/src/cli/cmd/run/runtime.lifecycle.ts

@@ -196,7 +196,11 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
     const theme = await resolveRunTheme(renderer)
     renderer.setBackgroundColor(theme.background)
     const keymap = createDefaultOpenTuiKeymap(renderer)
-    unregisterKeymap = registeranymousKeymap(keymap, renderer, input.tuiConfig)
+    unregisterKeymap = registeranymousKeymap(
+      keymap as Parameters<typeof registeranymousKeymap>[0],
+      renderer,
+      input.tuiConfig,
+    )
     const state: SplashState = {
       entry: false,
       exit: false,
@@ -267,7 +271,7 @@ export async function createRuntimeLifecycle(input: LifecycleInput): Promise<Lif
           return await openEditor({
             value,
             cwd: input.directory,
-            renderer,
+            renderer: renderer as Parameters<typeof openEditor>[0]["renderer"],
             stdin: source.stdin,
           })
         } finally {

package/src/cli/cmd/run/theme.ts

@@ -681,8 +681,8 @@ export async function resolveRunTheme(renderer: CliRenderer): Promise<RunTheme>
       footerTheme,
       scrollbackTheme,
       splashTheme(scrollbackTheme, indexed),
-      syntax,
-      shared.generateSubtleSyntax(syntaxTheme),
+      syntax as unknown as SyntaxStyle,
+      shared.generateSubtleSyntax(syntaxTheme) as unknown as SyntaxStyle,
     )
   } catch {
     return RUN_THEME_FALLBACK

package/src/cli/cmd/tui.ts

@@ -16,7 +16,7 @@ import { validateSession } from "../tui/validate-session"
 import { win32InstallCtrlCGuard } from "@anymous-ai/tui/terminal-win32"
 
 declare global {
-  const ANYMOUS_WORKER_PATH: string
+  var ANYMOUS_WORKER_PATH: string
 }
 
 type RpcClient = ReturnType<typeof Rpc.client<typeof rpc>>

package/src/effect/app-runtime.ts

@@ -46,6 +46,7 @@ import { Worktree } from "@/worktree"
 import { Installation } from "@/installation"
 import { ShareNext } from "@/share/share-next"
 import { SessionShare } from "@/share/session"
+import { Memory } from "@/memory/memory"
 import { Npm } from "@anymous-ai/core/npm"
 import { memoMap } from "@anymous-ai/core/effect/memo-map"
 import { BackgroundJob } from "@/background/job"
@@ -105,6 +106,7 @@ export const AppLayer = AppNodeBuilderV1.build(
     Installation.node,
     ShareNext.node,
     SessionShare.node,
+    Memory.node,
   ]),
 ).pipe(Layer.provideMerge(AppNodeBuilderV1.build(Ripgrep.node)), Layer.provideMerge(Observability.layer))
 

package/src/memory/memory.ts

@@ -1,5 +1,5 @@
 import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { Effect, Layer, Context, Schema, ParseResult } from "effect"
+import { Effect, Layer, Context, Schema } from "effect"
 import { FSUtil } from "@anymous-ai/core/fs-util"
 import { Global } from "@anymous-ai/core/global"
 import path from "path"
@@ -39,8 +39,8 @@ const loadStore = (fs: FSUtil.Interface, filePath: string) =>
     }
     const raw = yield* fs.readFileString(filePath)
     const parsed = JSON.parse(raw) as unknown
-    const decoded = yield* Schema.decodeUnknown(MemoryStore)(parsed).pipe(
-      Effect.catchAll(() => Effect.succeed({ version: 1, memories: [] } as MemoryStoreType)),
+    const decoded = yield* Effect.sync(() => Schema.decodeUnknownSync(MemoryStore)(parsed)).pipe(
+      Effect.catch(() => Effect.succeed({ version: 1, memories: [] } as MemoryStoreType)),
     )
     return decoded
   })
@@ -58,38 +58,44 @@ const layer = Layer.effect(
     const filePath = memoryFilePath(global)
 
     const read: Interface["read"] = Effect.fn("Memory.read")(function* (key: string) {
-      const store = yield* loadStore(fs, filePath)
+      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
       return store.memories.find((m) => m.key === key)
     })
 
-    const write: Interface["write"] = Effect.fn("Memory.write")(function* (key: string, value: string, sessionID?: string) {
-      const store = yield* loadStore(fs, filePath)
-      const existing = store.memories.findIndex((m) => m.key === key)
+    const write: Interface["write"] = Effect.fn("Memory.write")(function* (
+      key: string,
+      value: string,
+      sessionID?: string,
+    ) {
+      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
+      const memories = [...store.memories]
+      const existing = memories.findIndex((m) => m.key === key)
       const entry: MemoryEntryType = { key, value, timestamp: Date.now(), ...(sessionID ? { sessionID } : {}) }
       if (existing >= 0) {
-        store.memories[existing] = entry
+        memories[existing] = entry
       } else {
-        store.memories.push(entry)
+        memories.push(entry)
       }
-      yield* saveStore(fs, filePath, store)
+      yield* saveStore(fs, filePath, { ...store, memories }).pipe(Effect.orDie)
     })
 
     const list: Interface["list"] = Effect.fn("Memory.list")(function* () {
-      const store = yield* loadStore(fs, filePath)
-      return store.memories
+      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
+      return [...store.memories]
     })
 
     const remove: Interface["delete"] = Effect.fn("Memory.delete")(function* (key: string) {
-      const store = yield* loadStore(fs, filePath)
-      const idx = store.memories.findIndex((m) => m.key === key)
+      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
+      const memories = [...store.memories]
+      const idx = memories.findIndex((m) => m.key === key)
       if (idx < 0) return false
-      store.memories.splice(idx, 1)
-      yield* saveStore(fs, filePath, store)
+      memories.splice(idx, 1)
+      yield* saveStore(fs, filePath, { ...store, memories }).pipe(Effect.orDie)
       return true
     })
 
     const allText: Interface["allText"] = Effect.fn("Memory.allText")(function* () {
-      const store = yield* loadStore(fs, filePath)
+      const store = yield* loadStore(fs, filePath).pipe(Effect.orDie)
       if (store.memories.length === 0) return undefined
       const lines = store.memories.map((m) => `- ${m.key}: ${m.value}`)
       return `## Shared Context / Memory\n\n${lines.join("\n")}`

package/src/server/routes/instance/httpapi/server.ts

@@ -18,6 +18,7 @@ import { Git } from "@/git"
 import { Installation } from "@/installation"
 import { LSP } from "@/lsp/lsp"
 import { MCP } from "@/mcp"
+import { Memory } from "@/memory/memory"
 import { McpAuth } from "@/mcp/auth"
 import { Permission } from "@/permission"
 import { Plugin } from "@/plugin"
@@ -260,6 +261,7 @@ const app = LayerNode.group([
   Installation.node,
   ShareNext.node,
   SessionShare.node,
+  Memory.node,
   InstanceStore.node,
   httpClient,
   EventV2.node,

package/src/tool/computer.ts

@@ -216,7 +216,7 @@ const typeText = Effect.fn("Computer.typeText")(function* (text: string, delayMs
   } else {
     for (const char of text) {
       yield* typeChar(char)
-      if (delayMs > 0) yield* Effect.promise<void>((resolve) => setTimeout(resolve, delayMs))
+      if (delayMs > 0) yield* Effect.sleep(delayMs)
     }
   }
 })

package/src/tool/memory.ts

@@ -4,7 +4,7 @@ import { Memory } from "@/memory/memory"
 import DESCRIPTION from "./memory.txt"
 
 export const Parameters = Schema.Struct({
-  action: Schema.Literal("read", "write", "delete", "list").annotate({ description: "Action to perform" }),
+  action: Schema.Literals(["read", "write", "delete", "list"]).annotate({ description: "Action to perform" }),
   key: Schema.optional(Schema.String).annotate({ description: "Memory key (required for read/write/delete)" }),
   value: Schema.optional(Schema.String).annotate({ description: "Memory value (required for write)" }),
 })

package/src/tool/registry.ts

@@ -4,6 +4,7 @@ import { Ripgrep } from "@anymous-ai/core/ripgrep"
 import { PlanExitTool } from "./plan"
 import { ComputerTool } from "./computer"
 import { MemoryTool } from "./memory"
+import { Memory } from "@/memory/memory"
 import { Session } from "@/session/session"
 import { QuestionTool } from "./question"
 import { ShellTool } from "./shell"
@@ -450,6 +451,7 @@ export const node = LayerNode.make({
     Truncate.node,
     RuntimeFlags.node,
     MCP.node,
+    Memory.node,
     Database.node,
     Ripgrep.node,
   ],

package/tsconfig.json

@@ -12,5 +12,6 @@
       "@/*": ["./src/*"],
       "@test/*": ["./test/*"]
     }
-  }
+  },
+  "exclude": ["dist-npm", "node_modules"]
 }