@chinhae/atw-cli 0.1.0

package/dist/templates/opencode/lib/context-visibility.js

@@ -0,0 +1,148 @@
+import { createHash } from "node:crypto"
+
+const PART_ID_PATTERN = /^prt_([0-9a-f]{12})[0-9A-Za-z]{14}$/
+const CONTEXT_PART_KINDS = {
+  sessionStart: { offset: 2n, slot: "0" },
+  workflowState: { offset: 1n, slot: "1" },
+}
+const MAX_CONTEXT_PART_OFFSET = Object.values(CONTEXT_PART_KINDS).reduce(
+  (maximum, definition) => definition.offset > maximum ? definition.offset : maximum,
+  0n,
+)
+
+/**
+ * Return the first ordinary user-authored text part.
+ *
+ * ATW plugins can run in either order, so callers must not mistake a
+ * synthetic context part inserted by another plugin for the user's prompt.
+ */
+export function findUserTextPart(parts) {
+  if (!Array.isArray(parts)) return undefined
+  return parts.find(
+    part => part?.type === "text" && part.synthetic !== true && part.text !== undefined,
+  )
+}
+
+function findIdentitySourcePart(parts) {
+  return parts
+    .filter(
+      part =>
+        part?.synthetic !== true &&
+        typeof part?.id === "string" &&
+        typeof part?.sessionID === "string" &&
+        typeof part?.messageID === "string" &&
+        PART_ID_PATTERN.test(part.id),
+    )
+    .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))[0]
+}
+
+function contextPartId(source, kind) {
+  const definition = CONTEXT_PART_KINDS[kind]
+  if (!definition) throw new TypeError(`unknown context part kind: ${kind}`)
+
+  const match = PART_ID_PATTERN.exec(source.id)
+  if (!match) throw new TypeError(`unsupported OpenCode part ID: ${source.id}`)
+  const sourceOrdinal = BigInt(`0x${match[1]}`)
+  if (sourceOrdinal <= MAX_CONTEXT_PART_OFFSET) {
+    throw new TypeError(`unsupported OpenCode part ID ordinal: ${source.id}`)
+  }
+  const ordinal = sourceOrdinal - definition.offset
+  const suffix = createHash("sha256")
+    .update(`${source.messageID}\0${kind}`)
+    .digest("hex")
+    .slice(0, 13)
+  return `prt_${ordinal.toString(16).padStart(12, "0")}${definition.slot}${suffix}`
+}
+
+/**
+ * Persist machine-authored context ahead of the ordinary user parts without
+ * mutating any existing part. The generated identity sorts before the source
+ * user part in the same order during both the first request and stored replay.
+ */
+export function insertSyntheticTextPart(parts, text, kind) {
+  if (!Array.isArray(parts)) throw new TypeError("parts must be an array")
+  if (typeof text !== "string") throw new TypeError("text must be a string")
+  if (!CONTEXT_PART_KINDS[kind]) throw new TypeError(`unknown context part kind: ${kind}`)
+
+  const source = findIdentitySourcePart(parts)
+  if (!source) throw new TypeError("no ordinary OpenCode part with a persisted identity")
+
+  const id = contextPartId(source, kind)
+  if (parts.some(part => part?.id === id)) {
+    throw new TypeError(`duplicate synthetic context part: ${kind}`)
+  }
+  const part = {
+    id,
+    sessionID: source.sessionID,
+    messageID: source.messageID,
+    type: "text",
+    text,
+    synthetic: true,
+  }
+  const insertionIndex = parts.findIndex(existing => typeof existing?.id !== "string" || id < existing.id)
+  if (insertionIndex === -1) parts.push(part)
+  else parts.splice(insertionIndex, 0, part)
+  return part
+}
+
+/** OpenCode hook that mutates the in-memory model payload, not stored history. */
+export const MESSAGES_TRANSFORM_HOOK = "experimental.chat.messages.transform"
+
+/**
+ * Index of the last user message in an OpenCode `{info, parts}[]` transcript.
+ * Compaction and prompt both pass that shape to messages.transform.
+ */
+export function findLatestUserMessageIndex(messages) {
+  if (!Array.isArray(messages)) return -1
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.info?.role === "user") return i
+  }
+  return -1
+}
+
+export function platformInputFromMessages(messages) {
+  const index = findLatestUserMessageIndex(messages)
+  if (index < 0) return null
+  const info = messages[index].info
+  if (!info || typeof info !== "object") return null
+  return {
+    sessionID: info.sessionID,
+    agent: info.agent,
+  }
+}
+
+export function latestUserPromptText(messages) {
+  const index = findLatestUserMessageIndex(messages)
+  if (index < 0) return ""
+  const part = findUserTextPart(messages[index].parts)
+  return typeof part?.text === "string" ? part.text : ""
+}
+
+export function transcriptHasAssistantMessage(messages) {
+  if (!Array.isArray(messages)) return false
+  return messages.some(message => message?.info?.role === "assistant")
+}
+
+/**
+ * Clone the latest user message and prepend an ephemeral synthetic text
+ * part. The original message object and its `parts` array are left
+ * untouched so a transform cannot leak into OpenCode's stored history.
+ */
+export function prependEphemeralText(messages, text) {
+  if (!Array.isArray(messages)) return false
+  if (typeof text !== "string") return false
+  const index = findLatestUserMessageIndex(messages)
+  if (index < 0) return false
+  const original = messages[index]
+  const parts = Array.isArray(original.parts) ? original.parts.slice() : []
+  parts.unshift({
+    type: "text",
+    text,
+    synthetic: true,
+  })
+  messages[index] = {
+    ...original,
+    parts,
+  }
+  return true
+}

package/dist/templates/opencode/lib/session-utils.js

@@ -0,0 +1,474 @@
+/* global process */
+import { existsSync, readFileSync, readdirSync, statSync } from "fs"
+import { join } from "path"
+import { execFileSync } from "child_process"
+import { platform } from "os"
+import { debugLog } from "./atw-context.js"
+
+const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
+
+const FIRST_REPLY_NOTICE = `<first-reply-notice>
+On the first visible assistant reply in this session, briefly acknowledge that ATW SessionStart context loaded.
+Choose the acknowledgment language in this order:
+1. Use the language of the user's current request (the user message that triggered this reply).
+2. If that request has no clear natural language, use an explicitly established project communication language.
+3. If neither provides a language, output the language-neutral fallback exactly: \`ATW SessionStart ✓\`.
+Continue directly with the user's request after the acknowledgment.
+The acknowledgment must not alter the language used for the remainder of the response.
+This notice is one-shot: do not repeat it after the first visible assistant reply in this session.
+</first-reply-notice>`
+
+function getTaskStatus(ctx, platformInput = null) {
+  const active = ctx.getActiveTask(platformInput)
+  const taskRef = active.taskPath
+  if (!taskRef) {
+    return (
+      "Status: NO ACTIVE TASK\n" +
+      "Next-Action: Classify the current turn before creating any ATW task. " +
+      "Simple conversation / small task asks only whether this turn should create an ATW task. " +
+      "Complex task asks whether task creation and planning are allowed."
+    )
+  }
+
+  const taskDir = ctx.resolveTaskDir(taskRef)
+
+  if (active.stale || !taskDir || !existsSync(taskDir)) {
+    return `Status: STALE POINTER\nTask: ${taskRef}\nNext-Action: Task directory not found. Run: python3 ./.atw/scripts/task.py finish`
+  }
+
+  let taskData = {}
+  const taskJsonPath = join(taskDir, "task.json")
+  if (existsSync(taskJsonPath)) {
+    try {
+      taskData = JSON.parse(readFileSync(taskJsonPath, "utf-8"))
+    } catch {
+      // Ignore parse errors
+    }
+  }
+
+  const taskTitle = taskData.title || taskRef
+  const taskStatus = taskData.status || "unknown"
+
+  if (taskStatus === "completed") {
+    return `Status: COMPLETED\nTask: ${taskTitle}\nNext-Action: The archive was interrupted — re-run \`task.py archive <task>\` to finish it. If the working tree is dirty, commit or set the task back to \`implement\` first; there is no wrap-up commit step.`
+  }
+
+  const artifactNames = ["prd.md", "implement.jsonl", "check.jsonl"]
+  const present = artifactNames.filter(name => existsSync(join(taskDir, name)))
+  if (existsSync(join(taskDir, "research"))) present.push("research/")
+  const presentLine = present.length > 0 ? present.join(", ") : "(none)"
+
+  return (
+    `Status: ${String(taskStatus).toUpperCase()}\nTask: ${taskTitle}\n` +
+    `Present: ${presentLine}\n` +
+    "Next-Action: Follow the matching per-turn workflow-state. " +
+    "Implementation/check context order is jsonl entries -> `prd.md`."
+  )
+}
+
+function loadAtwConfig(directory, contextKey = null) {
+  const scriptPath = join(directory, ".atw", "scripts", "get_context.py")
+  if (!existsSync(scriptPath)) {
+    return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+  }
+  try {
+    const output = execFileSync(PYTHON_CMD, [scriptPath, "--mode", "packages", "--json"], {
+      cwd: directory,
+      timeout: 5000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        ...(contextKey ? { ATW_CONTEXT_ID: contextKey } : {}),
+      },
+    })
+    const data = JSON.parse(output)
+    if (data.mode !== "monorepo") {
+      return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+    }
+    const pkgDict = {}
+    for (const pkg of (data.packages || [])) {
+      pkgDict[pkg.name] = pkg
+    }
+    return {
+      isMonorepo: true,
+      packages: pkgDict,
+      specScope: data.specScope || null,
+      activeTaskPackage: data.activeTaskPackage || null,
+      defaultPackage: data.defaultPackage || null,
+    }
+  } catch (e) {
+    debugLog("session", "loadAtwConfig error:", e.message)
+    return { isMonorepo: false, packages: {}, specScope: null, activeTaskPackage: null, defaultPackage: null }
+  }
+}
+
+function checkLegacySpec(directory, config) {
+  if (!config.isMonorepo || Object.keys(config.packages).length === 0) {
+    return null
+  }
+
+  const specDir = join(directory, ".atw", "spec")
+  if (!existsSync(specDir)) return null
+
+  let hasLegacy = false
+  for (const name of ["backend", "frontend"]) {
+    if (existsSync(join(specDir, name, "index.md"))) {
+      hasLegacy = true
+      break
+    }
+  }
+  if (!hasLegacy) return null
+
+  const pkgNames = Object.keys(config.packages).sort()
+  const missing = pkgNames.filter(name => !existsSync(join(specDir, name)))
+
+  if (missing.length === 0) return null
+
+  if (missing.length === pkgNames.length) {
+    return (
+      `[!] Legacy spec structure detected: found \`spec/backend/\` or \`spec/frontend/\` ` +
+      `but no package-scoped \`spec/<package>/\` directories.\n` +
+      `Monorepo packages: ${pkgNames.join(", ")}\n` +
+      `Please reorganize: \`spec/backend/\` -> \`spec/<package>/backend/\``
+    )
+  }
+  return (
+    `[!] Partial spec migration detected: packages ${missing.join(", ")} ` +
+    `still missing \`spec/<pkg>/\` directory.\n` +
+    `Please complete migration for all packages.`
+  )
+}
+
+function resolveSpecScope(config) {
+  if (!config.isMonorepo || Object.keys(config.packages).length === 0) {
+    return null
+  }
+
+  const { specScope, activeTaskPackage, defaultPackage, packages } = config
+  if (specScope == null) return null
+
+  if (specScope === "active_task") {
+    if (activeTaskPackage && activeTaskPackage in packages) return new Set([activeTaskPackage])
+    if (defaultPackage && defaultPackage in packages) return new Set([defaultPackage])
+    return null
+  }
+
+  if (Array.isArray(specScope)) {
+    const valid = new Set()
+    for (const entry of specScope) {
+      if (entry in packages) {
+        valid.add(entry)
+      }
+    }
+    if (valid.size > 0) return valid
+    if (activeTaskPackage && activeTaskPackage in packages) return new Set([activeTaskPackage])
+    if (defaultPackage && defaultPackage in packages) return new Set([defaultPackage])
+    return null
+  }
+
+  return null
+}
+
+function collectSpecIndexPaths(directory, allowedPkgs) {
+  const specDir = join(directory, ".atw", "spec")
+  const paths = []
+
+  const guidesIndex = join(specDir, "guides", "index.md")
+  if (existsSync(guidesIndex)) {
+    paths.push(".atw/spec/guides/index.md")
+  }
+
+  if (!existsSync(specDir)) return paths
+
+  try {
+    const subs = readdirSync(specDir).filter(name => {
+      if (name.startsWith(".") || name === "guides") return false
+      try {
+        return statSync(join(specDir, name)).isDirectory()
+      } catch {
+        return false
+      }
+    }).sort()
+
+    for (const sub of subs) {
+      const indexFile = join(specDir, sub, "index.md")
+      if (existsSync(indexFile)) {
+        paths.push(`.atw/spec/${sub}/index.md`)
+      } else {
+        if (allowedPkgs !== null && !allowedPkgs.has(sub)) continue
+        try {
+          const nested = readdirSync(join(specDir, sub)).filter(name => {
+            try {
+              return statSync(join(specDir, sub, name)).isDirectory()
+            } catch {
+              return false
+            }
+          }).sort()
+          for (const layer of nested) {
+            const nestedIndex = join(specDir, sub, layer, "index.md")
+            if (existsSync(nestedIndex)) {
+              paths.push(`.atw/spec/${sub}/${layer}/index.md`)
+            }
+          }
+        } catch {
+          // Ignore directory read errors
+        }
+      }
+    }
+  } catch {
+    // Ignore spec directory read errors
+  }
+
+  return paths
+}
+
+function readDeveloper(directory) {
+  try {
+    const content = readFileSync(join(directory, ".atw", ".developer"), "utf-8")
+    for (const line of content.split(/\r?\n/)) {
+      if (line.startsWith("name=")) return line.slice("name=".length).trim()
+    }
+  } catch {
+    // Ignore missing developer file
+  }
+  return "(not initialized)"
+}
+
+function runGit(directory, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd: directory,
+      timeout: 3000,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim()
+  } catch {
+    return ""
+  }
+}
+
+function buildCompactCurrentState(ctx, platformInput, specIndexPaths) {
+  const directory = ctx.directory
+  const lines = []
+  lines.push(`Developer: ${readDeveloper(directory)}`)
+
+  const branch = runGit(directory, ["branch", "--show-current"]) || "(detached)"
+  const dirtyCount = runGit(directory, ["status", "--porcelain"])
+    .split(/\r?\n/)
+    .filter(line => line.trim()).length
+  lines.push(`Git: branch ${branch}; ${dirtyCount === 0 ? "clean" : `dirty ${dirtyCount} paths`}.`)
+
+  const active = ctx.getActiveTask(platformInput)
+  if (active.taskPath) {
+    const taskDir = ctx.resolveTaskDir(active.taskPath)
+    let status = "unknown"
+    if (taskDir) {
+      try {
+        const data = JSON.parse(readFileSync(join(taskDir, "task.json"), "utf-8"))
+        status = data.status || "unknown"
+      } catch {
+        // Ignore parse errors
+      }
+    }
+    lines.push(`Current task: ${active.taskPath}; status=${status}.`)
+  } else {
+    lines.push("Current task: none.")
+  }
+
+  const tasksDir = join(directory, ".atw", "tasks")
+  if (existsSync(tasksDir)) {
+    try {
+      const activeTasks = readdirSync(tasksDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && entry.name !== "archive" && existsSync(join(tasksDir, entry.name, "task.json")))
+      lines.push(`Active tasks: ${activeTasks.length} total. Use \`python3 ./.atw/scripts/task.py list --mine\` only if needed.`)
+    } catch {
+      // Ignore task list errors
+    }
+  }
+
+  const developer = readDeveloper(directory)
+  const workspaceDir = join(directory, ".atw", "workspace", developer)
+  if (developer !== "(not initialized)" && existsSync(workspaceDir)) {
+    try {
+      const journals = readdirSync(workspaceDir)
+        .filter(name => /^journal-\d+\.md$/.test(name))
+        .sort((a, b) => Number(a.match(/\d+/)?.[0] || 0) - Number(b.match(/\d+/)?.[0] || 0))
+      const journal = journals[journals.length - 1]
+      if (journal) {
+        const journalPath = join(workspaceDir, journal)
+        const lineCount = readFileSync(journalPath, "utf-8").split(/\r?\n/).length
+        lines.push(`Journal: .atw/workspace/${developer}/${journal}, ${lineCount} / 2000 lines.`)
+      }
+    } catch {
+      // Ignore journal errors
+    }
+  }
+
+  if (specIndexPaths.length > 0) {
+    lines.push(`Spec indexes: ${specIndexPaths.length} available.`)
+  }
+
+  return lines.join("\n")
+}
+
+export function buildSessionContext(ctx, platformInput = null) {
+  const directory = ctx.directory
+  const contextKey = typeof ctx.getContextKey === "function"
+    ? ctx.getContextKey(platformInput)
+    : null
+
+  const config = loadAtwConfig(directory, contextKey)
+  const allowedPkgs = resolveSpecScope(config)
+  const paths = collectSpecIndexPaths(directory, allowedPkgs)
+
+  const parts = []
+
+  parts.push(`<session-context>
+ATW compact SessionStart context. Use it to orient the session; load details on demand.
+</session-context>`)
+  parts.push(FIRST_REPLY_NOTICE)
+
+  const legacyWarning = checkLegacySpec(directory, config)
+  if (legacyWarning) {
+    parts.push(`<migration-warning>\n${legacyWarning}\n</migration-warning>`)
+  }
+
+  parts.push("<current-state>")
+  parts.push(buildCompactCurrentState(ctx, platformInput, paths))
+  parts.push("</current-state>")
+
+  const workflowContent = ctx.readProjectFile(".atw/workflow.md")
+  if (workflowContent) {
+    const allLines = workflowContent.split("\n")
+    const overviewLines = [
+      "# Development Workflow - Session Summary",
+      "Full guide: .atw/workflow.md. Step detail: `python3 ./.atw/scripts/get_context.py --mode phase --step <X.Y>`.",
+      "",
+    ]
+
+    let rangeStart = -1
+    let rangeEnd = allLines.length
+    for (let i = 0; i < allLines.length; i++) {
+      const stripped = allLines[i].trim()
+      if (rangeStart === -1 && stripped === "## Phase Index") {
+        rangeStart = i
+      } else if (rangeStart !== -1 && stripped === "## Phase 1: Plan") {
+        rangeEnd = i
+        break
+      }
+    }
+    if (rangeStart !== -1) {
+      const strippedStateBlocks = allLines
+        .slice(rangeStart, rangeEnd)
+        .join("\n")
+        .replace(/\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n[\s\S]*?\n\s*\[\/workflow-state:\1\]\n?/g, "")
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .replace(/^\[(?!\/?workflow-state:)\/?[^\]\n]+\]\s*\n?/gm, "")
+        .replace(/\n{3,}/g, "\n\n")
+      overviewLines.push(strippedStateBlocks.trimEnd())
+    }
+
+    parts.push("<atw-workflow>")
+    parts.push(overviewLines.join("\n").trimEnd())
+    parts.push("</atw-workflow>")
+  }
+
+  parts.push("<guidelines>")
+  parts.push(
+    "Task context order for implementation/check: jsonl entries -> `prd.md`.\n"
+  )
+
+  if (paths.length > 0) {
+    parts.push("## Available indexes (read on demand)")
+    for (const p of paths) {
+      parts.push(`- ${p}`)
+    }
+    parts.push("")
+  }
+
+  parts.push(
+    "Discover more via: " +
+    "`python3 ./.atw/scripts/get_context.py --mode packages`"
+  )
+  parts.push("</guidelines>")
+
+  const taskStatus = getTaskStatus(ctx, platformInput)
+  parts.push(`<task-status>\n${taskStatus}\n</task-status>`)
+
+  parts.push(`<ready>
+Context loaded. Follow <task-status>. Load workflow/spec/task details only when needed.
+</ready>`)
+
+  return parts.join("\n\n")
+}
+
+function getAtwMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return {}
+  }
+
+  const atw = metadata.atw
+  if (!atw || typeof atw !== "object") {
+    return {}
+  }
+
+  return atw
+}
+
+function markPartAsSessionStart(part) {
+  const metadata = part.metadata && typeof part.metadata === "object"
+    ? part.metadata
+    : {}
+  part.metadata = {
+    ...metadata,
+    atw: {
+      ...getAtwMetadata(metadata),
+      sessionStart: true,
+    },
+  }
+}
+
+function hasSessionStartMarker(part) {
+  if (!part || part.type !== "text" || typeof part.text !== "string") {
+    return false
+  }
+
+  return getAtwMetadata(part.metadata).sessionStart === true
+}
+
+export function hasInjectedAtwContext(messages) {
+  if (!Array.isArray(messages)) {
+    return false
+  }
+
+  return messages.some(message => {
+    if (!message?.info || message.info.role !== "user" || !Array.isArray(message.parts)) {
+      return false
+    }
+
+    return message.parts.some(hasSessionStartMarker)
+  })
+}
+
+export async function hasPersistedInjectedContext(client, directory, sessionID) {
+  try {
+    const response = await client.session.messages({
+      path: { id: sessionID },
+      query: { directory },
+      throwOnError: true,
+    })
+    return hasInjectedAtwContext(response.data || [])
+  } catch (error) {
+    debugLog(
+      "session",
+      "Failed to read session history for dedupe:",
+      error instanceof Error ? error.message : String(error),
+    )
+    return false
+  }
+}
+
+export function markContextInjected(part) {
+  markPartAsSessionStart(part)
+}

package/dist/templates/opencode/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.14.39"
+  }
+}