antcolony

3.8 KB

1. \* hl:proc — child processes as INSTANCE EVENTS.
3. let server = spawn('llama-server -m ' + model + ' --port 8480')
4. on server.line({ line, stream }) { … } \\ stream: 'stdout' | 'stderr'
5. on server.exit({ exit, pid }) { … } \\ always arrives, kill or not
6. server.kill() \\ SIGTERM; exit still fires
8. `stream` names the PIPE, not a verdict — most servers (llama.cpp included)
9. write their whole LOG to stderr, keeping stdout for data.
11. A command that CANNOT START has no exit — it is an ERROR: caught by
12. `on server.Error(e)` (this instance) or the global `on Error(e)`; uncaught
13. it is a located crash naming the binary and the errno. A finished child
14. retires its event source, so a program whose children are done simply ends.
16. THE PROGRAM PATH follows the Hybriel path rule: `spawn('bin/llama-server …')`
17. resolves bin/ against THIS SCRIPT's directory (like imports and hl:fs) — a
18. copied build folder next to your .hl file just works. A bare name searches
19. PATH; absolute stays absolute.
21. There is NO SHELL — no quoting, no expansion (the safety property, not a
22. gap). `spawnArgs([ 'sh', '-c', pipeline ])` is how you ASK for one,
23. explicitly. *\
25. /* Gate file (docs campaign): __native lives only here; the Process class
26. (process.hl) carries the instance events and their declarations. */
28. \* Start a child from ONE command string: split on WHITESPACE RUNS (spaces,
29. tabs AND newlines — a command written across lines is one command); a
30. quoted argument is GROUPED and its quotes stripped ('{"a": 1}' arrives as
31. one argv entry). A command that cannot start is an Error — caught by
32. `on server.Error(e)` or the global `on Error(e)`. *\
33. spawn(
34. String cmd \\ the program and its arguments, whitespace-separated
35. ) {
36. return new Process().start(cmd)
37. }
39. \* The LIST form — argv exactly as given: for arguments that contain spaces,
40. or to ask for a shell explicitly: spawnArgs([ 'sh', '-c', pipeline ]). *\
41. spawnArgs(
42. Hybrid args \\ argv entries, one string each — args[0] is the program
43. ) {
44. return new Process().startArgs(args)
45. }
47. \* The terminal's own input as instance events — `input = stdin()`, then
48. `on input.line(text)` per typed line and `on input.eof()` at Ctrl-D. A joined
49. terminal realm (SPEC "Joining a realm") reads its keyboard here. *\
50. stdin() {
51. return new Stdin().start()
52. }
54. \* One environment variable, null when unset. The runtime loads a `.env`
55. beside the project's entry BEFORE anything runs (KEY=VALUE lines, #
56. comments; the real environment always wins), so env('OPENROUTER_KEY')
57. reads either source through one call. *\
58. env(
59. String name \\ the variable's name
60. ) {
61. return __native("proc.env", name)
62. }
64. \* THE PROGRAM'S OWN ARGUMENTS (mission 317) — the strings that follow the
65. entry on the command line, in order, as a list; an empty list when there
66. were none.
68. hybriel lex.hl a b // args() is ['a', 'b']
69. ./lex a b // the compiled binary answers the same
71. A project DIRECTORY entry is unchanged: `hybriel <projectDir> <realm>` still
72. JOINS that realm, so the positional there is the realm's name and never an
73. argument (SPEC "Joining a realm").
75. Built here rather than handed over whole because a `__native` call answers
76. with ONE value and a list is what the caller wants: the count and the i-th
77. argument are the two questions the runtime can answer, and the list is the
78. language's own. *\
79. args() {
80. let out = []
81. let n = __native("proc.argc")
82. let i = 0
83. while (i < n) {
84. out.push(__native("proc.arg", i))
85. i = i + 1
86. }
87. return out
88. }
90. \* The process's current working directory, absolute — where the USER
91. launched from. Your own files resolve script-relatively everywhere
92. (imports, hl:fs, spawn); cwd() is for tools whose subject is the caller's
93. directory: a formatter, a scaffolder. *\
94. cwd() {
95. return __native("proc.cwd")
96. }