pi-obsidian-memory 0.0.0 → 0.1.0

package/src/domain/search-catalog/inspection.ts

@@ -0,0 +1,47 @@
+import type { InspectedVaultFile, VaultCatalogEntry, VaultCatalogFailure } from "#src/domain/vault-catalog"
+import { semanticFingerprint } from "./fingerprint.ts"
+import type { AliasFailureClassification, CatalogEntry } from "./types.ts"
+
+export function inspectedCatalogEntry(file: InspectedVaultFile, validationFingerprint: string): CatalogEntry {
+  const entry: CatalogEntry = {
+    path: file.path,
+    stat: { size: file.stat.size, mtimeMs: file.stat.mtimeMs },
+    rawHash: file.rawHash,
+    contentFingerprint: null,
+    validationFingerprint,
+    note: null,
+    needsFixing: file.analysis.needsFixing,
+  }
+  const analysis = file.analysis
+  if (analysis.status !== "parsed" || !analysis.frontmatter) return entry
+  entry.note = {
+    id: analysis.frontmatter.id,
+    type: analysis.frontmatter.type,
+    statement: analysis.parsed.statement,
+    body: analysis.parsed.body,
+    dontForget: "dontForget" in analysis.frontmatter,
+    archived: !analysis.searchable,
+  }
+  entry.contentFingerprint = semanticFingerprint(entry.note)
+  return entry
+}
+
+export function reusableCatalogEntry(
+  file: VaultCatalogEntry,
+  cached: CatalogEntry,
+  validationFingerprint: string,
+): boolean {
+  return (
+    cached.validationFingerprint === validationFingerprint &&
+    cached.stat.size === file.stat.size &&
+    cached.stat.mtimeMs === file.stat.mtimeMs
+  )
+}
+
+export function classifyAliasFailure(failure: VaultCatalogFailure): AliasFailureClassification {
+  if (failure.reason === "excluded" || failure.reason === "cycle") {
+    if (failure.scope === "file") return { kind: "excluded-file", path: failure.path }
+    return { kind: "untraversed-directory", path: failure.path }
+  }
+  return { kind: "failed", path: failure.path, problems: failure.problems }
+}

package/src/domain/search-catalog/plan.ts

@@ -0,0 +1,68 @@
+import { confirmedMissing, retiredAliasPath } from "./coverage.ts"
+import type { CatalogEntry, CatalogPlan, CatalogScan, CatalogSnapshot, DuplicateCatalogId } from "./types.ts"
+
+export function planCatalogChanges(snapshot: CatalogSnapshot, scan: CatalogScan): CatalogPlan {
+  const previous = new Map(snapshot.entries.map((entry) => [entry.path, entry]))
+  const plan: CatalogPlan = {
+    expectedRevision: snapshot.revision,
+    upserts: [],
+    deletes: [],
+    statUpdates: [],
+    duplicateIds: [],
+    reinspectPaths: [],
+    population: snapshot.population,
+  }
+
+  for (const entry of scan.entries) classifyEntry(entry, previous.get(entry.path), plan)
+  plan.deletes = snapshot.entries
+    .filter((entry) => confirmedMissing(entry.path, scan) || retiredAliasPath(entry.path, scan))
+    .map((entry) => entry.path)
+
+  const current = new Map(previous)
+  for (const path of plan.deletes) current.delete(path)
+  for (const entry of scan.entries) current.set(entry.path, entry)
+
+  plan.reinspectPaths = [...current.values()]
+    .filter((entry) => entry.validationFingerprint !== scan.validationFingerprint)
+    .map((entry) => entry.path)
+  if (scan.complete && scan.failedPaths.length === 0 && plan.reinspectPaths.length === 0) plan.population = "ready"
+
+  plan.duplicateIds = duplicateIds([...current.values()])
+  return plan
+}
+
+function classifyEntry(entry: CatalogEntry, previous: CatalogEntry | undefined, plan: CatalogPlan): void {
+  if (!previous || !sameContent(entry, previous)) {
+    plan.upserts.push(entry)
+    return
+  }
+
+  if (entry.stat.size !== previous.stat.size || entry.stat.mtimeMs !== previous.stat.mtimeMs) {
+    plan.statUpdates.push({ path: entry.path, stat: entry.stat })
+  }
+}
+
+function sameContent(left: CatalogEntry, right: CatalogEntry): boolean {
+  return (
+    left.rawHash === right.rawHash &&
+    left.validationFingerprint === right.validationFingerprint &&
+    left.contentFingerprint === right.contentFingerprint &&
+    left.needsFixing === right.needsFixing &&
+    JSON.stringify(left.note) === JSON.stringify(right.note)
+  )
+}
+
+function duplicateIds(entries: CatalogEntry[]): DuplicateCatalogId[] {
+  const paths = new Map<string, string[]>()
+  for (const entry of entries) {
+    if (!entry.note) continue
+    const group = paths.get(entry.note.id)
+    if (group) group.push(entry.path)
+    else paths.set(entry.note.id, [entry.path])
+  }
+
+  return [...paths]
+    .filter(([, group]) => group.length > 1)
+    .map(([id, group]) => ({ id, paths: group.sort() }))
+    .sort((left, right) => left.id.localeCompare(right.id))
+}

package/src/domain/search-catalog/ranking.ts

@@ -0,0 +1,27 @@
+import { standardRrfK } from "./constants.ts"
+import type { FusedPath, ScoredPath } from "./types.ts"
+
+export function fuseRankings(text: readonly string[], semantic: readonly string[]): FusedPath[] {
+  return [...new Set([...text, ...semantic])]
+    .map((path) => ({ path, score: reciprocalRank(text, path) + reciprocalRank(semantic, path) }))
+    .sort((left, right) => right.score - left.score || compareText(left.path, right.path))
+}
+
+function reciprocalRank(ranking: readonly string[], path: string): number {
+  const index = ranking.indexOf(path)
+  if (index < 0) return 0
+  return 1 / (standardRrfK + index + 1)
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1
+  if (left > right) return 1
+  return 0
+}
+
+export function semanticRanking(scored: readonly ScoredPath[], minimumSimilarity: number | null): string[] {
+  return scored
+    .filter((item) => typeof minimumSimilarity !== "number" || item.similarity >= minimumSimilarity)
+    .sort((left, right) => right.similarity - left.similarity || compareText(left.path, right.path))
+    .map((item) => item.path)
+}

package/src/domain/search-catalog/schemas.ts

@@ -0,0 +1,49 @@
+import Type from "typebox"
+
+import { NoteIdSchema, NoteTypeSchema } from "#src/domain/note"
+
+export const CatalogPathSchema = Type.String({
+  minLength: 1,
+  pattern: "^(?!/)(?!.*//)(?!.*(?:^|/)\\.{1,2}(?:/|$))[^\\\\:]+(?<!/)$",
+})
+
+export const CatalogStatSchema = Type.Object(
+  {
+    size: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+    mtimeMs: Type.Number(),
+  },
+  { additionalProperties: false },
+)
+
+export const CatalogNoteSchema = Type.Object(
+  {
+    id: NoteIdSchema,
+    type: NoteTypeSchema,
+    statement: Type.String(),
+    body: Type.String(),
+    dontForget: Type.Boolean(),
+    archived: Type.Boolean(),
+  },
+  { additionalProperties: false },
+)
+
+export const CatalogEntrySchema = Type.Object(
+  {
+    path: CatalogPathSchema,
+    stat: CatalogStatSchema,
+    rawHash: Type.String({ minLength: 1 }),
+    contentFingerprint: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+    validationFingerprint: Type.String({ minLength: 1 }),
+    note: Type.Union([CatalogNoteSchema, Type.Null()]),
+    needsFixing: Type.Boolean(),
+  },
+  { additionalProperties: false },
+)
+
+export const VectorGenerationSchema = Type.Object(
+  {
+    fingerprint: Type.String({ minLength: 1 }),
+    dimensions: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  },
+  { additionalProperties: false },
+)

package/src/domain/search-catalog/types.ts

@@ -0,0 +1,103 @@
+import type { Static } from "typebox"
+
+import type { CatalogEntrySchema, CatalogStatSchema, VectorGenerationSchema } from "./schemas.ts"
+
+export type CatalogEntry = Static<typeof CatalogEntrySchema>
+export type CatalogStat = Static<typeof CatalogStatSchema>
+export type VectorGeneration = Static<typeof VectorGenerationSchema>
+export type CatalogPopulation = "needs-population" | "ready"
+
+export interface CatalogSnapshot {
+  entries: CatalogEntry[]
+  population: CatalogPopulation
+  revision: number
+}
+
+export interface CatalogScan {
+  entries: CatalogEntry[]
+  observedPaths: string[]
+  completeDirectories: string[]
+  failedPaths: string[]
+  untraversedAliasDirectories: string[]
+  excludedAliasFiles: string[]
+  validationFingerprint: string
+  complete: boolean
+}
+
+export interface CatalogStatUpdate {
+  path: string
+  stat: CatalogStat
+}
+
+export interface CatalogChanges {
+  expectedRevision: number
+  upserts: CatalogEntry[]
+  deletes: string[]
+  statUpdates: CatalogStatUpdate[]
+  population: CatalogPopulation
+}
+
+export interface DuplicateCatalogId {
+  id: string
+  paths: string[]
+}
+
+export interface CatalogPlan extends CatalogChanges {
+  duplicateIds: DuplicateCatalogId[]
+  reinspectPaths: string[]
+}
+
+export interface UntraversedAliasDirectory {
+  kind: "untraversed-directory"
+  path: string
+}
+
+export interface ExcludedAliasFile {
+  kind: "excluded-file"
+  path: string
+}
+
+export interface FailedAliasPath {
+  kind: "failed"
+  path: string
+  problems: string[]
+}
+
+export type AliasFailureClassification = UntraversedAliasDirectory | ExcludedAliasFile | FailedAliasPath
+
+export interface SemanticContent {
+  statement: string
+  body: string
+}
+
+export interface VectorChunk {
+  contentFingerprint: string
+  chunk: number
+  vector: number[]
+}
+
+export interface VectorCache {
+  generation: VectorGeneration | null
+  chunks: VectorChunk[]
+}
+
+export interface VectorRefreshPlan {
+  embed: CatalogEntry[]
+  keep: VectorChunk[]
+}
+
+export interface ScoredPath {
+  path: string
+  similarity: number
+}
+
+export interface FusedPath {
+  path: string
+  score: number
+}
+
+export interface VectorReplacement {
+  expectedRevision: number
+  generation: VectorGeneration
+  chunks: VectorChunk[]
+}

package/src/domain/search-catalog/vector-refresh.ts

@@ -0,0 +1,22 @@
+import type { CatalogEntry, VectorCache, VectorChunk, VectorRefreshPlan } from "./types.ts"
+
+export function planVectorRefresh(
+  entries: readonly CatalogEntry[],
+  cache: VectorCache,
+  providerFingerprint: string,
+): VectorRefreshPlan {
+  const current = new Map<string, CatalogEntry>()
+  for (const entry of entries) {
+    if (!entry.note || entry.note.archived || !entry.contentFingerprint) continue
+    if (!current.has(entry.contentFingerprint)) current.set(entry.contentFingerprint, entry)
+  }
+  if (cache.generation?.fingerprint !== providerFingerprint) return { embed: [...current.values()], keep: [] }
+
+  const keep: VectorChunk[] = cache.chunks.filter((chunk) => current.has(chunk.contentFingerprint))
+  const cached = new Set(keep.map((chunk) => chunk.contentFingerprint))
+  const embed: CatalogEntry[] = []
+  for (const [fingerprint, entry] of current) {
+    if (!cached.has(fingerprint)) embed.push(entry)
+  }
+  return { embed, keep }
+}

package/src/domain/shell-edit/command-segments.ts

@@ -0,0 +1,28 @@
+import { QUOTE_CHARACTERS } from "#src/domain/vault-access"
+
+export function commandSegments(command: string): string[] {
+  const segments: string[] = []
+  let current = ""
+  let quote = ""
+  for (const character of command) {
+    if (quote) {
+      if (character === quote) quote = ""
+      current += character
+    } else if (QUOTE_CHARACTERS.includes(character)) {
+      quote = character
+      current += character
+    } else if (endsSegment(character, current)) {
+      segments.push(current)
+      current = ""
+    } else if (character !== "&" || current.trim() !== "") {
+      current += character
+    }
+  }
+  segments.push(current)
+  return segments.filter((segment) => segment.trim() !== "")
+}
+
+function endsSegment(character: string, current: string): boolean {
+  if (character === ";" || character === "|" || character === "\n") return true
+  return character === "&" && current.trim() !== ""
+}

package/src/domain/shell-edit/command-words.ts

@@ -0,0 +1,22 @@
+import { QUOTE_CHARACTERS } from "#src/domain/vault-access"
+
+export function commandWords(segment: string): string[] {
+  const words: string[] = []
+  let current = ""
+  let quote = ""
+  for (const character of segment) {
+    if (quote) {
+      if (character === quote) quote = ""
+      else current += character
+    } else if (QUOTE_CHARACTERS.includes(character)) {
+      quote = character
+    } else if (/\s/.test(character)) {
+      if (current) words.push(current)
+      current = ""
+    } else {
+      current += character
+    }
+  }
+  if (current) words.push(current)
+  return words
+}

package/src/domain/shell-edit/constants.ts

@@ -0,0 +1,125 @@
+import { NPM_VALUE_FLAGS } from "#src/domain/tool-flags"
+import type { ShellEditQuestionName, ShellEditQuestions, ShellEditScores } from "./types.ts"
+
+export const SCRIPT_EXTENSION = /\.(?:sh|ps1)$/i
+
+export const LEADING_ENV_ASSIGNMENTS = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s"'])*\s+)+/
+
+export const EXECUTABLE_SUFFIX = /\.exe$/
+
+export const LAST_SEGMENT_START = /[^\\/]*$/
+
+const EVAL_AND_PRINT_FLAGS = ["-e", "--eval", "-p", "--print"]
+
+const PYTHON_INLINE_CODE_FLAGS = ["-c", "-m"]
+
+const SHELL_INLINE_CODE_FLAGS = ["-c"]
+
+export const INLINE_CODE_FLAGS = new Map([
+  ["node", [...EVAL_AND_PRINT_FLAGS, "-c", "--check"]],
+  ["tsx", EVAL_AND_PRINT_FLAGS],
+  ["ts-node", EVAL_AND_PRINT_FLAGS],
+  ["python", PYTHON_INLINE_CODE_FLAGS],
+  ["python3", PYTHON_INLINE_CODE_FLAGS],
+  ["py", PYTHON_INLINE_CODE_FLAGS],
+  ["bash", SHELL_INLINE_CODE_FLAGS],
+  ["sh", SHELL_INLINE_CODE_FLAGS],
+])
+
+export const BUN_INLINE_CODE_FLAGS = EVAL_AND_PRINT_FLAGS
+
+export const CONFIG_FILE_FLAGS = ["-c", "--config"]
+
+export const RUN_SUBCOMMAND = "run"
+
+export const NO_FLAGS: string[] = []
+
+export const PACKAGE_MANAGERS = new Map([
+  ["npm", NPM_VALUE_FLAGS],
+  ["pnpm", NO_FLAGS],
+  ["yarn", NO_FLAGS],
+])
+
+export const BUN_SOURCE_FILE = /[\\/]|\.(?:[cm]?[jt]sx?|sh|ps1)$/i
+
+export const PRELOAD_FLAGS = ["-r", "--require", "--import", "--preload", "--loader", "--experimental-loader"]
+
+export const PACKAGE_RUN_COMMANDS = ["run", "run-script"]
+
+export const PACKAGE_DIRECT_SCRIPTS = ["test", "start"]
+
+export const SHELL_EDIT_QUESTION_NAMES: readonly ShellEditQuestionName[] = [
+  "redirection",
+  "in_place",
+  "inline_code",
+  "script_writes",
+  "copy_download",
+  "hardlink",
+]
+
+export const SHELL_EDIT_QUESTIONS: ShellEditQuestions = {
+  redirection: {
+    type: "bool",
+    instructions:
+      "Does `command` write output into a file through a redirection (`>` or `>>`) or a file-writing cmdlet (`tee`, `Out-File`, `Set-Content`, `Add-Content`)?",
+    criteria: { true: "`command` sends output into a file", false: "`command` writes no output into any file" },
+  },
+  in_place: {
+    type: "bool",
+    instructions:
+      "Does `command` change an existing file in place, for example with `sed -i`, `perl -pi`, or text read from a file, changed with `-replace` and written back to it, rather than through a linter, formatter, test runner, build, git or a package manager?",
+    criteria: {
+      true: "`command` rewrites an existing file in place",
+      false: "`command` leaves existing files' contents as they are",
+    },
+  },
+  inline_code: {
+    type: "bool",
+    instructions:
+      "Does `command` carry inline code (`node -e`, `python -c`, a PowerShell `-Command` block or similar) whose code creates or writes a file?",
+    criteria: {
+      true: "the inline code in `command` creates or writes a file",
+      false: "`command` has no inline code, or its inline code writes no file",
+    },
+  },
+  script_writes: {
+    type: "bool",
+    instructions:
+      "Does the code in any `scripts[*].text` create or write a file with its own code, rather than only launching a linter, formatter, test runner, build, git or a package manager?",
+    criteria: {
+      true: "a script's own code creates or writes a file",
+      false: "no script's own code creates or writes a file",
+    },
+  },
+  copy_download: {
+    type: "bool",
+    instructions:
+      "Does `command` create a file by copying or downloading content (`cp`, `Copy-Item`, `curl -o`, `Invoke-WebRequest -OutFile`), other than through git or a package manager?",
+    criteria: {
+      true: "`command` creates a file by copying or downloading",
+      false: "`command` copies and downloads no file",
+    },
+  },
+  hardlink: {
+    type: "bool",
+    instructions:
+      "Does `command` create a hardlink (`ln` without `-s`, `New-Item -ItemType HardLink`, `mklink /H`, `fsutil hardlink create`)?",
+    criteria: { true: "`command` creates a hardlink", false: "`command` creates no hardlink" },
+  },
+}
+
+export const SHELL_EDIT_CUTOFFS: ShellEditScores = {
+  redirection: 0.5,
+  in_place: 0.5,
+  inline_code: 0.5,
+  script_writes: 0.5,
+  copy_download: 0.5,
+  hardlink: 0.5,
+}
+
+export const SHELL_EDIT_REFUSED = "Refused by the shell-edit guard"
+
+export const SHELL_EDIT_UNCHECKED = "Refused: the shell-edit guard could not check this command"
+
+export const SHELL_EDIT_GUIDANCE =
+  "The shell never creates or changes files: use the edit or write tool. Deleting, moving and renaming files, linters, formatters, git, npm and test runners stay allowed."

package/src/domain/shell-edit/executed-files.ts

@@ -0,0 +1,154 @@
+import { BUN_FOLDER_FLAGS, BUN_VALUE_FLAGS, INTERPRETER_VALUE_FLAGS } from "#src/domain/command-flags"
+import { NPM_PREFIX_FLAGS, NPM_WORKSPACE_FLAGS, POWERSHELL_PARAMETERS } from "#src/domain/tool-flags"
+import { commandSegments } from "./command-segments.ts"
+import { commandWords } from "./command-words.ts"
+import {
+  BUN_INLINE_CODE_FLAGS,
+  BUN_SOURCE_FILE,
+  CONFIG_FILE_FLAGS,
+  EXECUTABLE_SUFFIX,
+  INLINE_CODE_FLAGS,
+  LAST_SEGMENT_START,
+  LEADING_ENV_ASSIGNMENTS,
+  NO_FLAGS,
+  PACKAGE_DIRECT_SCRIPTS,
+  PACKAGE_MANAGERS,
+  PACKAGE_RUN_COMMANDS,
+  PRELOAD_FLAGS,
+  RUN_SUBCOMMAND,
+  SCRIPT_EXTENSION,
+} from "./constants.ts"
+import { powershellFiles, scriptFile } from "./powershell-files.ts"
+import type { ExecutedFile, FolderRead, InterpreterRules } from "./types.ts"
+
+export function executedFiles(command: string): ExecutedFile[] {
+  const found = new Map<string, ExecutedFile>()
+  for (const segment of commandSegments(command)) {
+    for (const file of segmentFiles(segment)) found.set(JSON.stringify(file), file)
+  }
+  return [...found.values()]
+}
+
+function segmentFiles(segment: string): ExecutedFile[] {
+  const [first, ...args] = commandWords(segment.replace(LEADING_ENV_ASSIGNMENTS, ""))
+  if (typeof first !== "string") return []
+  const program = programName(first)
+  const inlineCode = INLINE_CODE_FLAGS.get(program)
+  const withValue = INTERPRETER_VALUE_FLAGS.get(program)
+  if (inlineCode && withValue) {
+    return interpreterFiles(args, { inlineCode, withValue, folderFlags: NO_FLAGS, mainFile: scriptFile })
+  }
+  if (program === "bun") return bunFiles(args)
+  if (program === "deno") return denoFiles(args)
+  const powershellParameters = POWERSHELL_PARAMETERS.get(program)
+  if (powershellParameters) return powershellFiles(args, powershellParameters)
+  const packageFlags = PACKAGE_MANAGERS.get(program)
+  if (packageFlags) return packageScripts(args, packageFlags)
+  if (SCRIPT_EXTENSION.test(first)) return [scriptFile(first)]
+  return []
+}
+
+function programName(token: string): string {
+  const name = token.slice(token.search(LAST_SEGMENT_START))
+  return name.toLowerCase().replace(EXECUTABLE_SUFFIX, "")
+}
+
+function packageScript(name: string, prefix: string): ExecutedFile {
+  return { kind: "package-script", name, prefix }
+}
+
+function bunRunTarget(name: string, folder: string): ExecutedFile {
+  if (BUN_SOURCE_FILE.test(name)) return scriptFile(name)
+  return packageScript(name, folder)
+}
+
+function bunFiles(args: string[]): ExecutedFile[] {
+  const rules = {
+    inlineCode: BUN_INLINE_CODE_FLAGS,
+    withValue: BUN_VALUE_FLAGS,
+    folderFlags: BUN_FOLDER_FLAGS,
+    mainFile: scriptFile,
+  }
+  if (args[0] === RUN_SUBCOMMAND) return interpreterFiles(args.slice(1), { ...rules, mainFile: bunRunTarget })
+  return interpreterFiles(args, rules)
+}
+
+function denoFiles(args: string[]): ExecutedFile[] {
+  if (args[0] !== RUN_SUBCOMMAND) return []
+  const rules = { inlineCode: NO_FLAGS, withValue: CONFIG_FILE_FLAGS, folderFlags: NO_FLAGS, mainFile: scriptFile }
+  return interpreterFiles(args.slice(1), rules)
+}
+
+function assignedValue(arg: string, flags: string[]): string {
+  const equals = arg.indexOf("=")
+  if (equals < 0 || !flags.includes(arg.slice(0, equals))) return ""
+  return arg.slice(equals + 1)
+}
+
+function isAssignment(arg: string, flags: string[]): boolean {
+  return assignedValue(arg, flags) !== ""
+}
+
+function folderRead(args: string[], index: number, flags: string[]): FolderRead {
+  const arg = args[index]
+  const next = args[index + 1]
+  if (typeof arg !== "string") return { folder: "", width: 0 }
+  if (flags.includes(arg) && typeof next === "string") return { folder: next, width: 2 }
+  if (isAssignment(arg, flags)) return { folder: assignedValue(arg, flags), width: 1 }
+  return { folder: "", width: 0 }
+}
+
+function interpreterFiles(args: string[], rules: InterpreterRules): ExecutedFile[] {
+  const files: ExecutedFile[] = []
+  let folder = ""
+  let index = 0
+  for (let arg = args[index]; typeof arg === "string"; arg = args[index]) {
+    const next = args[index + 1]
+    const read = folderRead(args, index, rules.folderFlags)
+    if (rules.inlineCode.includes(arg)) return files
+    if (read.width > 0) {
+      folder = read.folder
+      index += read.width
+    } else if (rules.withValue.includes(arg)) {
+      index += 2
+    } else if (PRELOAD_FLAGS.includes(arg)) {
+      if (typeof next === "string") files.push(scriptFile(next))
+      index += 2
+    } else if (arg.startsWith("-")) {
+      index += 1
+    } else {
+      return [...files, rules.mainFile(arg, folder)]
+    }
+  }
+  return files
+}
+
+function packageScriptOf(words: string[], prefix: string): ExecutedFile[] {
+  const [first, second] = words
+  if (typeof first !== "string") return []
+  if (PACKAGE_DIRECT_SCRIPTS.includes(first)) return [packageScript(first, prefix)]
+  if (PACKAGE_RUN_COMMANDS.includes(first) && typeof second === "string") return [packageScript(second, prefix)]
+  return []
+}
+
+function packageScripts(args: string[], valueFlags: string[]): ExecutedFile[] {
+  const prefixFlags = NPM_PREFIX_FLAGS.filter((flag) => valueFlags.includes(flag))
+  const workspaceFlags = NPM_WORKSPACE_FLAGS.filter((flag) => valueFlags.includes(flag))
+  const words: string[] = []
+  let prefix = ""
+  let index = 0
+  for (let arg = args[index]; typeof arg === "string" && arg !== "--"; arg = args[index]) {
+    const read = folderRead(args, index, prefixFlags)
+    if (workspaceFlags.includes(arg) || isAssignment(arg, workspaceFlags)) return []
+    if (read.width > 0) {
+      prefix = read.folder
+      index += read.width
+    } else if (valueFlags.includes(arg)) {
+      index += 2
+    } else {
+      if (!arg.startsWith("-")) words.push(arg)
+      index += 1
+    }
+  }
+  return packageScriptOf(words, prefix)
+}

package/src/domain/shell-edit/index.ts

@@ -0,0 +1,6 @@
+export * from "./command-segments.ts"
+export * from "./command-words.ts"
+export * from "./constants.ts"
+export * from "./executed-files.ts"
+export * from "./rules.ts"
+export * from "./types.ts"