@farhanic017/octocode 3.5.0

package/src/sql.d.ts

@@ -0,0 +1,4 @@
+declare module "*.sql" {
+  const content: string
+  export default content
+}

package/src/storage/schema.ts

@@ -0,0 +1,5 @@
+export { AccountTable, AccountStateTable, ControlAccountTable } from "@octocode-ai/core/account/sql"
+export { ProjectTable } from "@octocode-ai/core/project/sql"
+export { SessionTable, MessageTable, PartTable, TodoTable } from "@octocode-ai/core/session/sql"
+export { SessionShareTable } from "@octocode-ai/core/share/sql"
+export { WorkspaceTable } from "@octocode-ai/core/control-plane/workspace.sql"

package/src/storage/storage.ts

@@ -0,0 +1,329 @@
+import * as Log from "@octocode-ai/core/util/log"
+import path from "path"
+import { Global } from "@octocode-ai/core/global"
+import { FSUtil } from "@octocode-ai/core/fs-util"
+import { Effect, Exit, Layer, Option, RcMap, Schema, Context, TxReentrantLock } from "effect"
+import { NonNegativeInt } from "@octocode-ai/core/schema"
+import { Git } from "@/git"
+
+const log = Log.create({ service: "storage" })
+
+type Migration = (dir: string, fs: FSUtil.Interface, git: Git.Interface) => Effect.Effect<void, FSUtil.Error>
+
+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("NotFoundError", {
+  message: Schema.String,
+}) {
+  static isInstance(input: unknown): input is NotFoundError {
+    return input instanceof NotFoundError
+  }
+}
+
+export type Error = FSUtil.Error | NotFoundError
+
+const RootFile = Schema.Struct({
+  path: Schema.optional(
+    Schema.Struct({
+      root: Schema.optional(Schema.String),
+    }),
+  ),
+})
+
+const SessionFile = Schema.Struct({
+  id: Schema.String,
+})
+
+const MessageFile = Schema.Struct({
+  id: Schema.String,
+})
+
+const DiffFile = Schema.Struct({
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt,
+})
+
+const SummaryFile = Schema.Struct({
+  id: Schema.String,
+  projectID: Schema.String,
+  summary: Schema.Struct({ diffs: Schema.Array(DiffFile) }),
+})
+
+const decodeRoot = Schema.decodeUnknownOption(RootFile)
+const decodeSession = Schema.decodeUnknownOption(SessionFile)
+const decodeMessage = Schema.decodeUnknownOption(MessageFile)
+const decodeSummary = Schema.decodeUnknownOption(SummaryFile)
+
+export interface Interface {
+  readonly remove: (key: string[]) => Effect.Effect<void, FSUtil.Error>
+  readonly read: <T>(key: string[]) => Effect.Effect<T, Error>
+  readonly update: <T>(key: string[], fn: (draft: T) => void) => Effect.Effect<T, Error>
+  readonly write: <T>(key: string[], content: T) => Effect.Effect<void, FSUtil.Error>
+  readonly list: (prefix: string[]) => Effect.Effect<string[][], FSUtil.Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@octocode/Storage") {}
+
+function file(dir: string, key: string[]) {
+  return path.join(dir, ...key) + ".json"
+}
+
+function missing(err: unknown) {
+  if (!err || typeof err !== "object") return false
+  if ("code" in err && err.code === "ENOENT") return true
+  if ("reason" in err && err.reason && typeof err.reason === "object" && "_tag" in err.reason) {
+    return err.reason._tag === "NotFound"
+  }
+  return false
+}
+
+function parseMigration(text: string) {
+  const value = Number.parseInt(text, 10)
+  return Number.isNaN(value) ? 0 : value
+}
+
+const MIGRATIONS: Migration[] = [
+  Effect.fn("Storage.migration.1")(function* (dir: string, fs: FSUtil.Interface, git: Git.Interface) {
+    const project = path.resolve(dir, "../project")
+    if (!(yield* fs.isDir(project))) return
+    const projectDirs = yield* fs.glob("*", {
+      cwd: project,
+      include: "all",
+    })
+    for (const projectDir of projectDirs) {
+      const full = path.join(project, projectDir)
+      if (!(yield* fs.isDir(full))) continue
+      log.info(`migrating project ${projectDir}`)
+      let projectID = projectDir
+      let worktree = "/"
+
+      if (projectID !== "global") {
+        for (const msgFile of yield* fs.glob("storage/session/message/*/*.json", {
+          cwd: full,
+          absolute: true,
+        })) {
+          const json = decodeRoot(yield* fs.readJson(msgFile), { onExcessProperty: "preserve" })
+          const root = Option.isSome(json) ? json.value.path?.root : undefined
+          if (!root) continue
+          worktree = root
+          break
+        }
+        if (!worktree) continue
+        if (!(yield* fs.isDir(worktree))) continue
+        const result = yield* git.run(["rev-list", "--max-parents=0", "--all"], {
+          cwd: worktree,
+        })
+        const [id] = result
+          .text()
+          .split("\n")
+          .filter(Boolean)
+          .map((x) => x.trim())
+          .toSorted()
+        if (!id) continue
+        projectID = id
+
+        yield* fs.writeWithDirs(
+          path.join(dir, "project", projectID + ".json"),
+          JSON.stringify(
+            {
+              id,
+              vcs: "git",
+              worktree,
+              time: {
+                created: Date.now(),
+                initialized: Date.now(),
+              },
+            },
+            null,
+            2,
+          ),
+        )
+
+        log.info(`migrating sessions for project ${projectID}`)
+        for (const sessionFile of yield* fs.glob("storage/session/info/*.json", {
+          cwd: full,
+          absolute: true,
+        })) {
+          const dest = path.join(dir, "session", projectID, path.basename(sessionFile))
+          log.info("copying", { sessionFile, dest })
+          const session = yield* fs.readJson(sessionFile)
+          const info = decodeSession(session, { onExcessProperty: "preserve" })
+          yield* fs.writeWithDirs(dest, JSON.stringify(session, null, 2))
+          if (Option.isNone(info)) continue
+          log.info(`migrating messages for session ${info.value.id}`)
+          for (const msgFile of yield* fs.glob(`storage/session/message/${info.value.id}/*.json`, {
+            cwd: full,
+            absolute: true,
+          })) {
+            const next = path.join(dir, "message", info.value.id, path.basename(msgFile))
+            log.info("copying", {
+              msgFile,
+              dest: next,
+            })
+            const message = yield* fs.readJson(msgFile)
+            const item = decodeMessage(message, { onExcessProperty: "preserve" })
+            yield* fs.writeWithDirs(next, JSON.stringify(message, null, 2))
+            if (Option.isNone(item)) continue
+
+            log.info(`migrating parts for message ${item.value.id}`)
+            for (const partFile of yield* fs.glob(`storage/session/part/${info.value.id}/${item.value.id}/*.json`, {
+              cwd: full,
+              absolute: true,
+            })) {
+              const out = path.join(dir, "part", item.value.id, path.basename(partFile))
+              const part = yield* fs.readJson(partFile)
+              log.info("copying", {
+                partFile,
+                dest: out,
+              })
+              yield* fs.writeWithDirs(out, JSON.stringify(part, null, 2))
+            }
+          }
+        }
+      }
+    }
+  }),
+  Effect.fn("Storage.migration.2")(function* (dir: string, fs: FSUtil.Interface) {
+    for (const item of yield* fs.glob("session/*/*.json", {
+      cwd: dir,
+      absolute: true,
+    })) {
+      const raw = yield* fs.readJson(item)
+      const session = decodeSummary(raw, { onExcessProperty: "preserve" })
+      if (Option.isNone(session)) continue
+      const diffs = session.value.summary.diffs
+      yield* fs.writeWithDirs(
+        path.join(dir, "session_diff", session.value.id + ".json"),
+        JSON.stringify(diffs, null, 2),
+      )
+      yield* fs.writeWithDirs(
+        path.join(dir, "session", session.value.projectID, session.value.id + ".json"),
+        JSON.stringify(
+          {
+            ...(raw as Record<string, unknown>),
+            summary: {
+              additions: diffs.reduce((sum, x) => sum + x.additions, 0),
+              deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
+            },
+          },
+          null,
+          2,
+        ),
+      )
+    }
+  }),
+]
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const git = yield* Git.Service
+    const locks = yield* RcMap.make({
+      lookup: () => TxReentrantLock.make(),
+      idleTimeToLive: 0,
+    })
+    const state = yield* Effect.cached(
+      Effect.gen(function* () {
+        const dir = path.join(Global.Path.data, "storage")
+        const marker = path.join(dir, "migration")
+        const migration = yield* fs.readFileString(marker).pipe(
+          Effect.map(parseMigration),
+          Effect.catchIf(missing, () => Effect.succeed(0)),
+          Effect.orElseSucceed(() => 0),
+        )
+        for (let i = migration; i < MIGRATIONS.length; i++) {
+          log.info("running migration", { index: i })
+          const step = MIGRATIONS[i]!
+          const exit = yield* Effect.exit(step(dir, fs, git))
+          if (Exit.isFailure(exit)) {
+            log.error("failed to run migration", { index: i, cause: exit.cause })
+            break
+          }
+          yield* fs.writeWithDirs(marker, String(i + 1))
+        }
+        return { dir }
+      }),
+    )
+
+    const fail = (target: string): Effect.Effect<never, NotFoundError> =>
+      Effect.fail(new NotFoundError({ message: `Resource not found: ${target}` }))
+
+    const wrap = <A>(target: string, body: Effect.Effect<A, FSUtil.Error>) =>
+      body.pipe(Effect.catchIf(missing, () => fail(target)))
+
+    const writeJson = Effect.fnUntraced(function* (target: string, content: unknown) {
+      yield* fs.writeWithDirs(target, JSON.stringify(content, null, 2))
+    })
+
+    const withResolved = <A, E>(
+      key: string[],
+      fn: (target: string, rw: TxReentrantLock.TxReentrantLock) => Effect.Effect<A, E>,
+    ): Effect.Effect<A, E | FSUtil.Error> =>
+      Effect.scoped(
+        Effect.gen(function* () {
+          const target = file((yield* state).dir, key)
+          return yield* fn(target, yield* RcMap.get(locks, target))
+        }),
+      )
+
+    const remove: Interface["remove"] = Effect.fn("Storage.remove")(function* (key: string[]) {
+      yield* withResolved(key, (target, rw) =>
+        TxReentrantLock.withWriteLock(rw, fs.remove(target).pipe(Effect.catchIf(missing, () => Effect.void))),
+      )
+    })
+
+    const read: Interface["read"] = <T>(key: string[]) =>
+      Effect.gen(function* () {
+        const value = yield* withResolved(key, (target, rw) =>
+          TxReentrantLock.withReadLock(rw, wrap(target, fs.readJson(target))),
+        )
+        return value as T
+      })
+
+    const update: Interface["update"] = <T>(key: string[], fn: (draft: T) => void) =>
+      Effect.gen(function* () {
+        const value = yield* withResolved(key, (target, rw) =>
+          TxReentrantLock.withWriteLock(
+            rw,
+            Effect.gen(function* () {
+              const content = yield* wrap(target, fs.readJson(target))
+              fn(content as T)
+              yield* writeJson(target, content)
+              return content
+            }),
+          ),
+        )
+        return value as T
+      })
+
+    const write: Interface["write"] = (key: string[], content: unknown) =>
+      Effect.gen(function* () {
+        yield* withResolved(key, (target, rw) => TxReentrantLock.withWriteLock(rw, writeJson(target, content)))
+      })
+
+    const list: Interface["list"] = Effect.fn("Storage.list")(function* (prefix: string[]) {
+      const dir = (yield* state).dir
+      const cwd = path.join(dir, ...prefix)
+      const result = yield* fs
+        .glob("**/*", {
+          cwd,
+          include: "file",
+        })
+        .pipe(Effect.catch(() => Effect.succeed<string[]>([])))
+      return result
+        .map((x) => [...prefix, ...x.slice(0, -5).split(path.sep)])
+        .toSorted((a, b) => a.join("/").localeCompare(b.join("/")))
+    })
+
+    return Service.of({
+      remove,
+      read,
+      update,
+      write,
+      list,
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(FSUtil.defaultLayer), Layer.provide(Git.defaultLayer))
+
+export * as Storage from "./storage"

package/src/swarm/evolution.ts

@@ -0,0 +1,304 @@
+import { Effect, Context, Layer, Schema } from "effect"
+import { InstanceState } from "@/effect/instance-state"
+import { FSUtil } from "@octocode-ai/core/fs-util"
+import path from "path"
+
+const DENIED_SKILL_TERMS = [
+  "steal",
+  "exfiltrate",
+  "credential",
+  "password",
+  "malware",
+  "bypass",
+  "disable security",
+  "delete user files",
+] as const
+
+export const SkillDraft = Schema.Struct({
+  name: Schema.String,
+  trigger: Schema.String,
+  purpose: Schema.String,
+  steps: Schema.Array(Schema.String),
+  evidence: Schema.Array(Schema.String),
+  version: Schema.Number,
+  confidence: Schema.Number,
+  tags: Schema.Array(Schema.String),
+})
+export type SkillDraft = Schema.Schema.Type<typeof SkillDraft>
+
+export const ValidationResult = Schema.Struct({
+  ok: Schema.Boolean,
+  issues: Schema.Array(Schema.String),
+  gates: Schema.Struct({
+    hasName: Schema.Boolean,
+    hasReusableSteps: Schema.Boolean,
+    safeTerms: Schema.Boolean,
+    boundedSize: Schema.Boolean,
+  }),
+})
+export type ValidationResult = Schema.Schema.Type<typeof ValidationResult>
+
+export interface Interface {
+  readonly proposeSkill: (input: {
+    task: string
+    outcome: string
+    lesson: string
+    agentName?: string
+  }) => Effect.Effect<{ draft: SkillDraft; validation: ValidationResult }>
+  readonly validateSkill: (draft: SkillDraft) => Effect.Effect<ValidationResult>
+  readonly persistSkill: (draft: SkillDraft) => Effect.Effect<{
+    saved: boolean
+    path: string
+    version: number
+    validation: ValidationResult
+  }>
+  readonly listEvolvedSkills: () => Effect.Effect<
+    Array<{ name: string; version: number; path: string; purpose: string; tags: string[] }>
+  >
+  readonly buildEvolutionPlan: (task: string) => Effect.Effect<{
+    task: string
+    evolutionLoop: string[]
+    guardrails: Record<string, boolean>
+  }>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@octocode/SwarmEvolution") {}
+
+function validateSkillSync(draft: SkillDraft): ValidationResult {
+  const text = `${draft.name} ${draft.purpose} ${draft.steps.join(" ")}`.toLowerCase()
+  const issues: string[] = []
+
+  if (!draft.name) issues.push("skill name is required")
+  if (draft.purpose.length < 12) issues.push("purpose is too short")
+  if (draft.steps.length < 3) issues.push("at least three reusable steps are required")
+  if (DENIED_SKILL_TERMS.some((term) => text.includes(term))) {
+    issues.push("unsafe or credential-related behavior is not allowed")
+  }
+  if (JSON.stringify(draft).length > 6000) {
+    issues.push("skill manifest is too large")
+  }
+
+  return {
+    ok: issues.length === 0,
+    issues,
+    gates: {
+      hasName: Boolean(draft.name),
+      hasReusableSteps: draft.steps.length >= 3,
+      safeTerms: !DENIED_SKILL_TERMS.some((term) => text.includes(term)),
+      boundedSize: JSON.stringify(draft).length <= 6000,
+    },
+  }
+}
+
+function inferSkillName(task: string, lesson: string): string {
+  const source = lesson || task || "hermes evolved skill"
+  const words = source
+    .split(/\s+/)
+    .map((w) => w.replace(/[.,:;!?\[\](){}]/g, "").toLowerCase())
+    .filter((w) => w.length > 3 && !["always", "should", "with", "from", "into", "using"].includes(w))
+  return (
+    words
+      .slice(0, 5)
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join(" ") || "Hermes Evolved Skill"
+  )
+}
+
+function inferSteps(text: string): string[] {
+  const steps = ["Identify when the pattern applies", "Execute the proven workflow", "Validate the result before handoff"]
+  if (/test|bug/.test(text)) steps.splice(2, 0, "Add regression tests for the discovered edge case")
+  if (/design|visual/.test(text)) steps.splice(1, 0, "Capture visual constraints and acceptance criteria")
+  if (/api|backend/.test(text)) steps.splice(1, 0, "Define inputs, outputs, permissions, and failure modes")
+  return steps
+}
+
+function inferTags(text: string, agentName: string): string[] {
+  const tags = new Set(["hermes", "self-evolved", agentName])
+  for (const token of ["testing", "design", "backend", "frontend", "security", "browser", "animation", "vision"]) {
+    if (text.includes(token)) tags.add(token)
+  }
+  return Array.from(tags).sort()
+}
+
+function confidenceScore(_task: string, outcome: string, lesson: string): number {
+  let score = 62
+  if (outcome) score += 10
+  if (lesson) score += 12
+  if (/passed|success|fixed|verified/.test(outcome.toLowerCase())) score += 10
+  return Math.min(96, score)
+}
+
+function compactSentence(value: string, limit: number): string {
+  return value.replace(/\s+/g, " ").trim().slice(0, limit)
+}
+
+function slug(value: string): string {
+  let safe = value
+    .toLowerCase()
+    .split("")
+    .map((ch) => (/[a-z0-9]/.test(ch) ? ch : "-"))
+    .join("")
+  while (safe.includes("--")) safe = safe.replace("--", "-")
+  return safe.replace(/^-|-$/g, "") || "hermes-skill"
+}
+
+type DirentEntry = { name: string; isDirectory: () => boolean }
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fsys = yield* FSUtil.Service
+
+    const proposeSkill = Effect.fn("SwarmEvolution.proposeSkill")(function* (input: {
+      task: string
+      outcome: string
+      lesson: string
+      agentName?: string
+    }) {
+      const name = inferSkillName(input.task, input.lesson)
+      const steps = inferSteps(`${input.task} ${input.outcome} ${input.lesson}`.toLowerCase())
+      const tags = inferTags(
+        `${input.task} ${input.outcome} ${input.lesson}`.toLowerCase(),
+        input.agentName ?? "hermes",
+      )
+
+      const draft: SkillDraft = {
+        name,
+        trigger: compactSentence(input.task, 140),
+        purpose: compactSentence(input.lesson || input.outcome || input.task, 220),
+        steps,
+        evidence: [compactSentence(input.outcome, 180), compactSentence(input.lesson, 180)].filter(Boolean),
+        version: 1,
+        confidence: confidenceScore(input.task, input.outcome, input.lesson),
+        tags,
+      }
+
+      return { draft, validation: validateSkillSync(draft) }
+    })
+
+    const validateSkill = Effect.fn("SwarmEvolution.validateSkill")((draft: SkillDraft) =>
+      Effect.succeed(validateSkillSync(draft)),
+    )
+
+    const persistSkill = Effect.fn("SwarmEvolution.persistSkill")(function* (draft: SkillDraft) {
+      const validation = validateSkillSync(draft)
+      if (!validation.ok) {
+        return { saved: false, path: "", version: 0, validation }
+      }
+
+      const dir = yield* InstanceState.directory
+      const evolvedDir = path.join(dir, ".octocode", "evolved_skills")
+      yield* fsys.ensureDir(evolvedDir).pipe(Effect.catch(() => Effect.succeed(undefined)))
+
+      const safe = slug(draft.name)
+      const target = path.join(evolvedDir, safe)
+      yield* fsys.ensureDir(target).pipe(Effect.catch(() => Effect.succeed(undefined)))
+
+      const version = 1
+      const manifest = path.join(target, `v${version}.json`)
+      const payload = {
+        ...draft,
+        version,
+        savedAt: Date.now(),
+        source: "hermes_self_evolution",
+      }
+
+      yield* Effect.tryPromise({
+        try: () =>
+          import("node:fs/promises").then((fs) => fs.writeFile(manifest, JSON.stringify(payload, null, 2), "utf-8")),
+        catch: (err) => err,
+      }).pipe(Effect.catch(() => Effect.succeed(undefined)))
+
+      const markdown = [
+        `# ${draft.name}`,
+        "",
+        `Version: ${version}`,
+        "",
+        `Purpose: ${draft.purpose}`,
+        "",
+        `Trigger: ${draft.trigger}`,
+        "",
+        `Tags: ${draft.tags.join(", ")}`,
+        "",
+        "## Workflow",
+        "",
+        ...draft.steps.map((step, i) => `${i + 1}. ${step}`),
+      ].join("\n")
+
+      yield* Effect.tryPromise({
+        try: () =>
+          import("node:fs/promises").then((fs) =>
+            fs.writeFile(path.join(target, "SKILL.md"), markdown, "utf-8"),
+          ),
+        catch: (err) => err,
+      }).pipe(Effect.catch(() => Effect.succeed(undefined)))
+
+      return { saved: true, path: manifest, version, validation }
+    })
+
+    const listEvolvedSkills = Effect.fn("SwarmEvolution.listEvolvedSkills")(function* () {
+      const dir = yield* InstanceState.directory
+      const evolvedDir = path.join(dir, ".octocode", "evolved_skills")
+      const exists = yield* fsys.existsSafe(evolvedDir).pipe(Effect.catch(() => Effect.succeed(false)))
+      if (!exists) return [] as Array<{ name: string; version: number; path: string; purpose: string; tags: string[] }>
+
+      const entries = yield* Effect.tryPromise({
+        try: () =>
+          import("node:fs/promises").then((fs) => fs.readdir(evolvedDir, { withFileTypes: true })),
+        catch: () => [] as DirentEntry[],
+      }).pipe(Effect.catch(() => Effect.succeed([] as DirentEntry[])))
+
+      const results: Array<{ name: string; version: number; path: string; purpose: string; tags: string[] }> = []
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        const manifestPath = path.join(evolvedDir, entry.name, "v1.json")
+        const manifestExists = yield* fsys.existsSafe(manifestPath).pipe(Effect.catch(() => Effect.succeed(false)))
+        if (!manifestExists) continue
+
+        const data = yield* Effect.tryPromise({
+          try: () => import("node:fs/promises").then((fs) => fs.readFile(manifestPath, "utf-8")),
+          catch: () => null as string | null,
+        }).pipe(Effect.catch(() => Effect.succeed(null as string | null)))
+
+        if (!data) continue
+        try {
+          const parsed = JSON.parse(data) as Record<string, unknown>
+          results.push({
+            name: (parsed.name as string) ?? entry.name,
+            version: (parsed.version as number) ?? 1,
+            path: manifestPath,
+            purpose: (parsed.purpose as string) ?? "",
+            tags: Array.isArray(parsed.tags) ? (parsed.tags as string[]) : [],
+          })
+        } catch {
+          // skip malformed files
+        }
+      }
+      return results
+    })
+
+    const buildEvolutionPlan = Effect.fn("SwarmEvolution.buildEvolutionPlan")((task: string) =>
+      Effect.succeed({
+        task,
+        evolutionLoop: [
+          "Observe successful work, failures, and repeated workflows",
+          "Compress the reusable pattern into a candidate skill",
+          "Validate safety, scope, and reuse gates",
+          "Save a versioned manifest and SKILL.md only after validation",
+          "Reuse the skill in future prompts when tags match the new task",
+        ],
+        guardrails: {
+          noUnreviewedCodeExecution: true,
+          noSecretOrCredentialSkills: true,
+          versionEverySkill: true,
+          keepSkillsSmallAndTaskScoped: true,
+          masterReviewBeforeReleaseUse: true,
+        },
+      }),
+    )
+
+    return Service.of({ proposeSkill, validateSkill, persistSkill, listEvolvedSkills, buildEvolutionPlan })
+  }),
+)
+
+export * as SwarmEvolution from "./evolution"

package/src/swarm/index.ts

@@ -0,0 +1,7 @@
+export { SwarmVision } from "./vision"
+export { SwarmEvolution } from "./evolution"
+export { SwarmLearning } from "./learning"
+
+export * as Vision from "./vision"
+export * as Evolution from "./evolution"
+export * as Learning from "./learning"