This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

180 lines
3.7 KiB
C

/*
* Copyright 2020 Google LLC
*
* Use of this source code is governed by a BSD-style
* license that can be found in the LICENSE file or at
* https://developers.google.com/open-source/licenses/bsd
*/
#include "system.h"
#include "basics.h"
#include "blocksource.h"
#include "reftable-blocksource.h"
#include "reftable-error.h"
void block_source_release_data(struct reftable_block_data *data)
{
struct reftable_block_source source = data->source;
if (data && source.ops)
source.ops->release_data(source.arg, data);
data->data = NULL;
data->len = 0;
data->source.ops = NULL;
data->source.arg = NULL;
}
void block_source_close(struct reftable_block_source *source)
{
if (!source->ops) {
return;
}
source->ops->close(source->arg);
source->ops = NULL;
}
ssize_t block_source_read_data(struct reftable_block_source *source,
struct reftable_block_data *dest, uint64_t off,
uint32_t size)
{
ssize_t result = source->ops->read_data(source->arg, dest, off, size);
dest->source = *source;
return result;
}
uint64_t block_source_size(struct reftable_block_source *source)
{
return source->ops->size(source->arg);
}
static void reftable_buf_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest)
{
if (dest->len)
memset(dest->data, 0xff, dest->len);
reftable_free(dest->data);
}
static void reftable_buf_close(void *b REFTABLE_UNUSED)
{
}
static ssize_t reftable_buf_read_data(void *v, struct reftable_block_data *dest,
uint64_t off, uint32_t size)
{
struct reftable_buf *b = v;
assert(off + size <= b->len);
REFTABLE_CALLOC_ARRAY(dest->data, size);
if (!dest->data)
return -1;
memcpy(dest->data, b->buf + off, size);
dest->len = size;
return size;
}
static uint64_t reftable_buf_size(void *b)
{
return ((struct reftable_buf *)b)->len;
}
static struct reftable_block_source_vtable reftable_buf_vtable = {
.size = &reftable_buf_size,
.read_data = &reftable_buf_read_data,
.release_data = &reftable_buf_release_data,
.close = &reftable_buf_close,
};
void block_source_from_buf(struct reftable_block_source *bs,
struct reftable_buf *buf)
{
assert(!bs->ops);
bs->ops = &reftable_buf_vtable;
bs->arg = buf;
}
struct file_block_source {
uint64_t size;
unsigned char *data;
};
static uint64_t file_size(void *b)
{
return ((struct file_block_source *)b)->size;
}
static void file_release_data(void *b REFTABLE_UNUSED, struct reftable_block_data *dest REFTABLE_UNUSED)
{
}
static void file_close(void *v)
{
struct file_block_source *b = v;
munmap(b->data, b->size);
reftable_free(b);
}
static ssize_t file_read_data(void *v, struct reftable_block_data *dest, uint64_t off,
uint32_t size)
{
struct file_block_source *b = v;
assert(off + size <= b->size);
dest->data = b->data + off;
dest->len = size;
return size;
}
static struct reftable_block_source_vtable file_vtable = {
.size = &file_size,
.read_data = &file_read_data,
.release_data = &file_release_data,
.close = &file_close,
};
int reftable_block_source_from_file(struct reftable_block_source *bs,
const char *name)
{
struct file_block_source *p = NULL;
struct stat st;
int fd, err;
fd = open(name, O_RDONLY);
if (fd < 0) {
if (errno == ENOENT)
return REFTABLE_NOT_EXIST_ERROR;
err = -1;
goto out;
}
if (fstat(fd, &st) < 0) {
err = REFTABLE_IO_ERROR;
goto out;
}
REFTABLE_CALLOC_ARRAY(p, 1);
if (!p) {
err = REFTABLE_OUT_OF_MEMORY_ERROR;
goto out;
}
p->size = st.st_size;
p->data = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (p->data == MAP_FAILED) {
err = REFTABLE_IO_ERROR;
p->data = NULL;
goto out;
}
assert(!bs->ops);
bs->ops = &file_vtable;
bs->arg = p;
err = 0;
out:
if (fd >= 0)
close(fd);
if (err < 0)
reftable_free(p);
return err;
}